Update main.py

main.py

@@ -103,53 +103,60 @@ def _normalize_lines(text: str) -> List[str]:
         return [raw.strip()] if raw.strip() else []
 
 def _ensure_numbering(text: str) -> str:
-    text = re.sub(r"[\u2060\u200B]", "", text or "")
-    def strip_prefix_any(s: str) -> str:
-    
-#Matches any leading list marker: numbers (1) or 1., 'Step N:', bullets -, *, •, circled numerals
-        pattern = (
-            r"^\s*(?:"          # start, optional spaces, non-capturing group
-            r"[\u2060\u200B]*"  # optional zero-width characters
-            r"(?:\d+\s*[.)]"    # classic numbers like '1)' or '2.'
-            r"|step\s*\d+:?"    # 'Step 3:' (case-insensitive via IGNORECASE)
-            r"|[\-\*\u2022]"    # bullets '-', '*', '•'
-            r"|[\u2460-\u2473])"  # circled numerals
-            r"\s*)"             # trailing spaces, close outer group  ← THIS ) WAS MISSING
+    """
+    Robust step numbering:
+    - Split by natural delimiters (newline, end-of-sentence, semicolons, arrows, 'then', simple bullets).
+    - Strip any existing list markers (numbers, 'Step N:', bullets).
+    - Return ①..⑳ then 'N)' beyond 20.
+    """
+    import re
+    t = (text or "").replace("\u2060", "").replace("\u200B", "")
+
+    # 1) Split to segments by common step delimiters
+    parts = re.split(
+        r"(?:\r?\n|\r|\u2028|\u2029)"         # newlines
+        r"|(?<=[.!?])\s+"                     # sentence end + space
+        r"|;\s+"                              # semicolons
+        r"|(?:\s*→\s*|\s*->\s*)"              # arrows
+        r"|(?:\s*\bthen\b\s*)"                # 'then'
+        r"|(?:^\s*[-*•]\s*)",                 # simple bullets
+        t,
+        flags=re.IGNORECASE
+    )
+
+    # 2) Clean segments & drop empties
+    cleaned = []
+    for seg in parts:
+        s = (seg or "").strip()
+        if not s:
+            continue
+        # Remove ANY leading list marker (1) / 2. / Step 3: / -, *, • / circled numerals
+        s = re.sub(
+            r"^\s*(?:"
+            r"(?:\d+\s*[.)])|"         # 1) or 2.
+            r"(?i:step\s*\d+:?)|"      # Step 3:
+            r"[-*•]|"                  # bullets
+            r"[\u2460-\u2473]"         # circled numerals
+            r")\s*",
+            "",
+            s
         )
-        return re.sub(pattern, "", (s or "").strip(), flags=re.IGNORECASE)
+        if s:
+            cleaned.append(s)
+
+    if not cleaned:
+        return (text or "").strip()
 
-    lines = [ln.strip() for ln in (text or "").splitlines() if ln and ln.strip()]
-    if not lines:
-        return text or ""
-    merged: List[str] = []
-    i = 0
-    while i < len(lines):
-        ln = lines[i]
-        if re.fullmatch(r"\d+[.)]|[\u2460-\u2473]", ln) and (i + 1) < len(lines):
-            merged.append(lines[i + 1].strip())
-            i += 2
-        else:
-            merged.append(ln)
-            i += 1
-    para = " ".join(merged).strip()
-    if not para:
-        return ""
-    para_clean = re.sub(r"(?:((?<=^)|(?<=\s))\d+[.)])\s+", "\n\n\n", para)
-    para_clean = re.sub(r"(?:((?<=^)|(?<=\s))[\u2460-\u2473])\s+", "\n\n\n", para_clean)
-    para_clean = re.sub(r"(?i)\bstep\s*\d+\s*:\s*", "\n\n\n", para_clean)
-    segments = [seg.strip() for seg in para_clean.split("\n\n\n") if seg.strip()]
-    if len(segments) < 2:
-        tmp = [ln.strip() for ln in para.splitlines() if ln.strip()]
-        segments = tmp if len(tmp) > 1 else [seg.strip() for seg in re.split(r"(?<=[.!?])\s+|;\s+", para) if seg.strip()]
-    segments = [strip_prefix_any(seg) for seg in segments if seg.strip()]
     circled = {
-        1:"\u2460",2:"\u2461",3:"\u2462",4:"\u2463",5:"\u2464",6:"\u2465",7:"\u2466",8:"\u2467",9:"\u2468",10:"\u2469",
-        11:"\u246a",12:"\u246b",13:"\u246c",14:"\u246d",15:"\u246e",16:"\u246f",17:"\u2470",18:"\u2471",19:"\u2472",20:"\u2473",
+        1:"\u2460",2:"\u2461",3:"\u2462",4:"\u2463",5:"\u2464",
+        6:"\u2465",7:"\u2466",8:"\u2467",9:"\u2468",10:"\u2469",
+        11:"\u246a",12:"\u246b",13:"\u246c",14:"\u246d",15:"\u246e",
+        16:"\u246f",17:"\u2470",18:"\u2471",19:"\u2472",20:"\u2473",
     }
-    out: List[str] = []
-    for idx, seg in enumerate(segments, start=1):
-        marker = circled.get(idx, f"{idx})")
-        out.append(f"{marker} {seg}")
+    out = []
+    for i, s in enumerate(cleaned, 1):
+        marker = circled.get(i, f"{i})")
+        out.append(f"{marker} {s}")
     return "\n".join(out)
 
 def _filter_error_lines_by_query(text: str, query: str, max_lines: int = 4) -> str:
@@ -597,19 +604,40 @@ async def chat_with_ai(input_data: ChatInput):
         # Prefer full SOP section when we have the best_doc
         escalation_line = None  # SOP escalation candidate (if found)
         if best_doc:
-            if detected_intent == "steps":
-                # PATCH: prefer action-filtered steps first
-                preferred_actions = kb_results.get("actions", []) or []
-                full_steps = get_steps_text_by_action(best_doc, preferred_actions)
-                if not full_steps:
-                    full_steps = get_best_steps_section_text(best_doc)
-                    if not full_steps:
-                        sec = (top_meta or {}).get("section")
-                        if sec: full_steps = get_section_text(best_doc, sec)
-                if full_steps:
-                    context = _ensure_numbering(full_steps)
-
-            elif detected_intent == "errors":
+           if detected_intent == "steps":
+        # 1) Prefer action-matched steps first (update/reschedule/edit vs create)
+              preferred_actions = kb_results.get("actions", []) or []
+              full_steps = get_steps_text_by_action(best_doc, preferred_actions)
+
+        # 2) If nothing found, fallback BUT FILTER creation-only when user asked update
+              if not full_steps:
+                 fallback = get_best_steps_section_text(best_doc)
+                 if preferred_actions and ("update" in [a.lower() for a in preferred_actions]):
+                # Drop lines that look like pure creation verbs when user asked update
+                     fallback_lines = [ln.strip() for ln in (fallback or "").splitlines() if ln.strip()]
+                     keep = []
+                     for ln in fallback_lines:
+                         low = ln.lower()
+                         is_creation_only = (
+                        ("create" in low or "creation" in low or " add " in low or " new " in low or " book " in low or " schedule " in low)
+                        and not any(x in low for x in ("update", "modify", "change", "edit", "amend", "reschedule", "re-schedule"))
+                    )
+                         if is_creation_only:
+                            continue  # skip creation-only line
+                         keep.append(ln)
+                     fallback = "\n".join(keep).strip()
+                     full_steps = fallback if (fallback and fallback.strip()) else full_steps
+
+                     if not full_steps:
+                       sec = (top_meta or {}).get("section")
+                       if sec:
+                          full_steps = get_section_text(best_doc, sec)
+
+              if full_steps:
+                  context = _ensure_numbering(full_steps)
+
+           elif detected_intent == "errors":
+
                 full_errors = get_best_errors_section_text(best_doc)
                 if full_errors:
                     # Extract the error lines from the SOP