Update main.py

main.py

@@ -21,7 +21,10 @@ from services.login import router as login_router
 from services.generate_ticket import get_valid_token, create_incident
 
 VERIFY_SSL = os.getenv("SERVICENOW_SSL_VERIFY", "true").lower() in ("1", "true", "yes")
-GEMINI_SSL_VERIFY = os.getenv("GEMINI_SSL_VERIFY", "true").lower() in ("1", "true", "yes")
+
+# --------------------------------------------------------
+# Utilities
+# --------------------------------------------------------
 
 def safe_str(e: Any) -> str:
     try:
@@ -53,7 +56,9 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# --- models ---
+# --------------------------------------------------------
+# Models
+# --------------------------------------------------------
 class ChatInput(BaseModel):
     user_message: str
     prev_status: Optional[str] = None
@@ -71,7 +76,9 @@ class TicketStatusInput(BaseModel):
     sys_id: Optional[str] = None
     number: Optional[str] = None
 
-# --- filters & extractors (no LLM) ---
+# --------------------------------------------------------
+# KB filters & extractors (no LLM)
+# --------------------------------------------------------
 STRICT_OVERLAP = 3
 MAX_SENTENCES_CONCISE = 6
 
@@ -177,7 +184,7 @@ def _extract_errors_only(text: str, max_lines: int = 12) -> str:
                 break
     return "\n".join(kept).strip() if kept else (text or "").strip()
 
-# ---- Escalation extractor (optional) ----
+# ---- Escalation extractor ----
 ESCALATION_REGEX = re.compile(r"^\s*Escalation Path|\s+→\s+", re.IGNORECASE)
 
 def _extract_escalation_only(text: str, max_lines: int = 3) -> str:
@@ -216,7 +223,9 @@ def _merge_number_only_lines(lines: List[str]) -> List[str]:
 def _strip_leading_mark(s: str) -> str:
     return re.sub(r"^\s*(?:\d+[\.)]\s+|[•\-]\s+)", "", (s or "")).strip()
 
-# --- conversation intents (RESTORED to fix NameError) ---
+# --------------------------------------------------------
+# Conversation intents & helpers
+# --------------------------------------------------------
 def _is_incident_intent(msg_norm: str) -> bool:
     intents = [
         "create ticket","create a ticket","raise ticket","raise a ticket","open ticket","open a ticket",
@@ -232,79 +241,122 @@ def _is_generic_issue(msg_norm: str) -> bool:
         "need support","please help","need assistance","assist me","facing issue","facing a problem","got a problem"
     ]
     return any(p == msg_norm or p in msg_norm for p in generic) or len(msg_norm.split()) <= 2
-    
+
+def _is_negative_feedback(msg_norm: str) -> bool:
+    phrases = [
+        "not resolved","issue not resolved","still not working","not working",
+        "didn't work","doesn't work","no change","not fixed","still failing",
+        "failed again","broken","fail","not solved","same issue"
+    ]
+    return any(p in msg_norm for p in phrases)
+
+# Parse status intent inside chat (e.g., "status INC0012345")
+def _parse_ticket_status_intent(msg_norm: str) -> Dict[str, Optional[str]]:
+    keywords = ["status", "ticket status", "incident status", "check status", "check ticket status", "check incident status"]
+    if not any(k in msg_norm for k in keywords):
+        return {}
+    # Try to capture INC number
+    m = re.search(r"(inc\d+)", msg_norm, flags=re.IGNORECASE)
+    if m:
+        val = m.group(1).strip().upper()
+        return {"number": val}
+    # Ask the user for number if not present
+    return {"ask_number": True}
+
+# --------------------------------------------------------
+# Error/escalation friendly composition
+# --------------------------------------------------------
 def _compose_errors_response(error_lines: List[str], escalation_lines: List[str]) -> str:
-    """
-    Turn SOP 'Common Errors & Resolution' + 'Escalation Path' into a friendly,
-    user-understandable reply.
-    """
     err = [ln.strip() for ln in (error_lines or []) if ln and ln.strip()]
     esc = [ln.strip() for ln in (escalation_lines or []) if ln and ln.strip()]
 
-    # 1) A one-line summary when permission/auth appears in the error lines
     summary = None
     joined = " ".join(err).lower()
-    if any(k in joined for k in ["permission", "authorized", "authorization", "role access", "not allowed", "insufficient"]):
+    if any(k in joined for k in ["permission","authorized","authorization","role access","not allowed","insufficient"]):
         summary = (
             "It looks like your role doesn’t allow Inventory Adjustment right now. "
             "Please verify you have the required authorization/role enabled. "
             "If you still cannot proceed, follow the escalation path below."
         )
 
-    # 2) Action bullets (convert SOP bullets into simpler points)
-    actions = []
+    actions: List[str] = []
     for ln in err:
         s = re.sub(r"^\s*(?:\d+[\.)]\s+|[•\-]\s+)", "", ln).strip()
-        # Light rewrite for common phrases
         s = s.replace("Verify role access", "Verify your role/access in WMS")
         s = s.replace("Check if cycle count or task is active", "Check if any cycle count/task is locking the location")
         s = s.replace("Confirm unit of measure setup", "Confirm the item’s UOM setup in master data")
-        s = s.replace("Adjustment not allowed:", "Adjustment not allowed:")
         if s:
             actions.append(f"• {s}")
 
-    # 3) Escalation line (if present)
     esc_text = ""
     if esc:
-        # pick the first escalation line and strip decorative arrows
         raw = esc[0]
-        clean = re.sub(r"^\s*Escalation Path\s*:\s*", "", raw, flags=re.IGNORECASE)
-        clean = clean.replace("→", "→").strip()
+        clean = re.sub(r"^\s*Escalation Path\s*:?\s*", "", raw, flags=re.IGNORECASE).strip()
         esc_text = f"\n\n**Escalation Path:** {clean}"
 
-    # Compose
     top = summary or "Here’s how to resolve this:"
     bullet_block = ("\n" + "\n".join(actions)) if actions else ""
     return f"{top}{bullet_block}{esc_text}".strip()
 
-
-def _extract_errors_and_escalation(context: str) -> Tuple[List[str], List[str]]:
-    """
-    Return (error_lines, escalation_lines) from the already-filtered SOP context.
-    """
-    lines = [ln.strip() for ln in (context or "").splitlines() if ln.strip()]
-    error_lines, escalation_lines = [], []
-    for ln in lines:
-        # Collect typical error/resolution bullets
-        if STEP_LINE_REGEX.match(ln) or ln.lower().startswith(("error", "resolution", "fix", "verify", "check", "not allowed")):
-            error_lines.append(ln)
-        # Collect escalation
-        if re.search(r"Escalation Path", ln, flags=re.IGNORECASE) or ("→" in ln):
-            escalation_lines.append(ln)
-    return error_lines, escalation_lines
-
-
+# --------------------------------------------------------
+# Health
+# --------------------------------------------------------
 @app.get("/")
 async def health_check():
     return {"status": "ok"}
 
+# --------------------------------------------------------
+# Chat endpoint
+# --------------------------------------------------------
 @app.post("/chat")
 async def chat_with_ai(input_data: ChatInput):
     try:
         msg_norm = (input_data.user_message or "").lower().strip()
 
-        # incident & generic handlers
+        # --- Negative feedback: proactively offer incident creation
+        if _is_negative_feedback(msg_norm):
+            return {
+                "bot_response": (
+                    "Sorry it’s still not resolved. I can open a ServiceNow incident to track and escalate.\n\n"
+                    "Please provide:\n• Short Description (one line)\n"
+                    "• Detailed Description (what you tried, exact error text, IDs, site, environment)"
+                ),
+                "status": "PARTIAL",
+                "context_found": False,
+                "ask_resolved": False,
+                "suggest_incident": True,
+                "show_incident_form": True,
+                "followup": None,
+                "top_hits": [], "sources": [],
+                "debug": {"intent": "negative_feedback"},
+            }
+
+        # --- Explicit incident intent: try direct creation if enough details; else show form
         if _is_incident_intent(msg_norm):
+            # If user message has more than the keywords, attempt immediate creation
+            minimal_phrases = ["create ticket", "create incident", "open ticket", "open incident", "raise ticket", "raise incident"]
+            has_only_minimal = any(msg_norm.strip() == p for p in minimal_phrases)
+            if not has_only_minimal and len(msg_norm.split()) > 3:
+                short_desc = input_data.user_message.strip()[:100]
+                long_desc  = input_data.user_message.strip()
+                try:
+                    result = create_incident(short_desc, long_desc)
+                    if isinstance(result, dict) and not result.get("error"):
+                        inc_number = result.get("number", "<unknown>")
+                        return {
+                            "bot_response": f"✅ Incident created: {inc_number}",
+                            "status": "OK",
+                            "context_found": False,
+                            "ask_resolved": False,
+                            "suggest_incident": False,
+                            "followup": "Is there anything else I can assist you with?",
+                            "top_hits": [], "sources": [],
+                            "debug": {"intent": "create_ticket_direct"},
+                        }
+                except Exception as e:
+                    # Fall back to form if direct creation fails
+                    pass
+            # Prompt for details & show form
             return {
                 "bot_response": (
                     "Okay, let’s create a ServiceNow incident.\n\n"
@@ -312,10 +364,12 @@ async def chat_with_ai(input_data: ChatInput):
                     "• Detailed Description (steps, error text, IDs, site, environment)"
                 ),
                 "status": (input_data.prev_status or "PARTIAL"),
-                "context_found": False, "ask_resolved": False, "suggest_incident": False,
+                "context_found": False, "ask_resolved": False, "suggest_incident": True,
                 "show_incident_form": True, "followup": None, "top_hits": [], "sources": [],
                 "debug": {"intent": "create_ticket"},
             }
+
+        # --- Generic openers
         if _is_generic_issue(msg_norm):
             return {
                 "bot_response": (
@@ -332,7 +386,58 @@ async def chat_with_ai(input_data: ChatInput):
                 "debug": {"intent": "generic_issue"},
             }
 
-        # Hybrid KB search
+        # --- Status intent inside chat
+        status_intent = _parse_ticket_status_intent(msg_norm)
+        if status_intent:
+            if status_intent.get("ask_number"):
+                return {
+                    "bot_response": "Please share the Incident ID (e.g., INC0012345) to check the status.",
+                    "status": "PARTIAL",
+                    "context_found": False,
+                    "ask_resolved": False,
+                    "suggest_incident": False,
+                    "show_status_form": True,
+                    "followup": "Provide the Incident ID and I’ll fetch the status.",
+                    "top_hits": [], "sources": [],
+                    "debug": {"intent": "status_request_missing_id"},
+                }
+            # fetch
+            try:
+                token = get_valid_token()
+                instance_url = os.getenv("SERVICENOW_INSTANCE_URL")
+                if not instance_url:
+                    raise HTTPException(status_code=500, detail="SERVICENOW_INSTANCE_URL missing")
+                headers = {"Authorization": f"Bearer {token}", "Accept": "application/json"}
+                number = status_intent.get("number")
+                url = f"{instance_url}/api/now/table/incident?number={number}"
+                response = requests.get(url, headers=headers, verify=VERIFY_SSL, timeout=25)
+                data = response.json()
+                lst = data.get("result", [])
+                result = (lst or [{}])[0] if response.status_code == 200 else {}
+                state_code = builtins.str(result.get("state", "unknown"))
+                state_map = {"1":"New","2":"In Progress","3":"On Hold","6":"Resolved","7":"Closed","8":"Canceled"}
+                state_label = state_map.get(state_code, state_code)
+                short = result.get("short_description", "")
+                num = result.get("number", number or "unknown")
+                return {
+                    "bot_response": (
+                        f"**Ticket:** {num}\n"
+                        f"**Status:** {state_label}\n"
+                        f"**Issue description:** {short}"
+                    ),
+                    "status": "OK",
+                    "show_assist_card": True,
+                    "context_found": False,
+                    "ask_resolved": False,
+                    "suggest_incident": False,
+                    "followup": "Is there anything else I can assist you with?",
+                    "top_hits": [], "sources": [],
+                    "debug": {"intent": "status", "http_status": response.status_code},
+                }
+            except Exception as e:
+                raise HTTPException(status_code=500, detail=safe_str(e))
+
+        # --- Hybrid KB search
         kb_results = hybrid_search_knowledge_base(input_data.user_message, top_k=10, alpha=0.6, beta=0.4)
 
         # Build a small context window
@@ -395,7 +500,7 @@ async def chat_with_ai(input_data: ChatInput):
         high_conf       = (best_combined is not None and best_combined >= gate_combined_ok)
         exact           = bool(exact_by_filter or high_conf)
 
-        # --- STEPS intent: full SOP steps (numbered) ---
+        # --- STEPS intent: full SOP steps (numbered)
         if detected_intent == "steps" and best_doc:
             full_steps = get_best_steps_section_text(best_doc)
             if not full_steps:
@@ -433,43 +538,39 @@ async def chat_with_ai(input_data: ChatInput):
                 },
             }
 
-        # --- Non-steps intents ---
+        # --- Non-steps intents
         context = filtered_text
         if detected_intent == "errors":
-    # Keep concise extraction, then compose friendly response
-           errs = _extract_errors_only(context, max_lines=MAX_SENTENCES_CONCISE)
-           esc  = _extract_escalation_only(context, max_lines=3)
-    # Build friendly paragraph + bullets from SOP lines
-           err_lines, esc_lines = _extract_errors_and_escalation(errs + ("\n" + esc if esc else ""))
-           bot_text = _compose_errors_response(err_lines, esc_lines)
-
-           status = "OK" if exact else "PARTIAL"
-           return {
+            errs = _extract_errors_only(context, max_lines=MAX_SENTENCES_CONCISE)
+            esc  = _extract_escalation_only(context, max_lines=3)
+            err_lines, esc_lines = _extract_errors_and_escalation(errs + ("\n" + esc if esc else ""))
+            bot_text = _compose_errors_response(err_lines, esc_lines)
+            status = "OK" if exact else "PARTIAL"
+            return {
                 "bot_response": bot_text,
                 "status": status,
                 "context_found": True,
                 "ask_resolved": (status == "OK"),
                 "suggest_incident": False,
                 "followup": ("Does this help? I can refine." if status == "PARTIAL" else None),
-                "top_hits": [],
-                "sources": [],
+                "top_hits": [], "sources": [],
                 "debug": {
-                  "used_chunks": len(context.split("\n\n---\n\n")) if context else 0,
-                  "best_distance": best_distance,
-                  "best_combined": best_combined,
-                  "filter_mode": filt_info.get("mode"),
-                  "matched_count": filt_info.get("matched_count"),
-                  "user_intent": detected_intent,
-                  "actions": actions,
-                  "best_doc": best_doc,
-                  "exact": exact,
-                  "high_conf": high_conf,
-        },
-    }
+                    "used_chunks": len(context.split("\n\n---\n\n")) if context else 0,
+                    "best_distance": best_distance,
+                    "best_combined": best_combined,
+                    "filter_mode": filt_info.get("mode"),
+                    "matched_count": filt_info.get("matched_count"),
+                    "user_intent": detected_intent,
+                    "actions": actions,
+                    "best_doc": best_doc,
+                    "exact": exact,
+                    "high_conf": high_conf,
+                },
+            }
         elif "navigate" in msg_norm or "menu" in msg_norm or "screen" in msg_norm:
             context = _extract_steps_only(context, max_lines=MAX_SENTENCES_CONCISE)
-    # fall through to default response below
-        # No-KB gate
+
+        # --- No-KB gate
         if (not context.strip()) or (
             (best_combined is None or best_combined < gate_combined_no_kb) and (best_distance is None or best_distance >= gate_distance_no_kb)
         ):
@@ -493,7 +594,7 @@ async def chat_with_ai(input_data: ChatInput):
                 "debug": {"used_chunks": 0, "second_try": second_try, "best_distance": best_distance, "best_combined": best_combined},
             }
 
-        # Default response for non-steps
+        # --- Default response for non-steps
         bot_text = context.strip()
         status   = "OK" if exact else "PARTIAL"
         return {
@@ -517,3 +618,83 @@ async def chat_with_ai(input_data: ChatInput):
         raise
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
+
+# --------------------------------------------------------
+# Incident endpoints (direct create + status + description)
+# --------------------------------------------------------
+@app.post("/incident")
+async def raise_incident(input_data: IncidentInput):
+    try:
+        result = create_incident(input_data.short_description, input_data.description)
+        if isinstance(result, dict) and not result.get("error"):
+            inc_number = result.get("number", "<unknown>")
+            return {
+                "bot_response": f"✅ Incident created: {inc_number}",
+                "debug": "Incident created via ServiceNow",
+                "persist": True,
+                "show_assist_card": True,
+                "followup": "Is there anything else I can assist you with?",
+            }
+        else:
+            err = (result or {}).get("error", "Unknown error")
+            return {
+                "bot_response": f"⚠️ Could not create incident ({err}).",
+                "status": "PARTIAL",
+                "suggest_incident": True,
+            }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=safe_str(e))
+
+@app.post("/incident_status")
+async def incident_status(input_data: TicketStatusInput):
+    try:
+        token = get_valid_token()
+        instance_url = os.getenv("SERVICENOW_INSTANCE_URL")
+        if not instance_url:
+            raise HTTPException(status_code=500, detail="SERVICENOW_INSTANCE_URL missing")
+        headers = {"Authorization": f"Bearer {token}", "Accept": "application/json"}
+        if input_data.sys_id:
+            url = f"{instance_url}/api/now/table/incident/{input_data.sys_id}"
+            response = requests.get(url, headers=headers, verify=VERIFY_SSL, timeout=25)
+            data = response.json()
+            result = data.get("result", {}) if response.status_code == 200 else {}
+        elif input_data.number:
+            url = f"{instance_url}/api/now/table/incident?number={input_data.number}"
+            response = requests.get(url, headers=headers, verify=VERIFY_SSL, timeout=25)
+            data = response.json()
+            lst = data.get("result", [])
+            result = (lst or [{}])[0] if response.status_code == 200 else {}
+        else:
+            raise HTTPException(status_code=400, detail="Provide IncidentID (number) or sys_id")
+        state_code = builtins.str(result.get("state", "unknown"))
+        state_map = {"1":"New","2":"In Progress","3":"On Hold","6":"Resolved","7":"Closed","8":"Canceled"}
+        state_label = state_map.get(state_code, state_code)
+        short = result.get("short_description", "")
+        number = result.get("number", input_data.number or "unknown")
+        return {
+            "bot_response": (
+                f"**Ticket:** {number}\n"
+                f"**Status:** {state_label}\n"
+                f"**Issue description:** {short}"
+            ).replace("\n", " \n"),
+            "followup": "Is there anything else I can assist you with?",
+            "show_assist_card": True,
+            "persist": True,
+            "debug": "Incident status fetched",
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=safe_str(e))
+
+@app.post("/generate_ticket_desc")
+async def generate_ticket_desc_ep(input_data: TicketDescInput):
+    try:
+        # Minimal: echo structured JSON (no external LLM)
+        issue = (input_data.issue or "").strip()
+        short = issue[:100]
+        detailed = issue
+        return {
+            "ShortDescription": short,
+            "DetailedDescription": detailed,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=safe_str(e))