Update context_parser.py

context_parser.py

@@ -1,84 +1,150 @@
 from __future__ import annotations
 
 import re
-from typing import Any, Dict, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 
 def split_unity_message(text: str) -> Tuple[str, str]:
     """
     Splits a Unity-style message into:
-    - game/context prefix
-    - user-facing message/question
+    - hidden/system/game context prefix
+    - actual user-facing message
 
-    If no structured prefix is found, returns ("", original_text).
+    If no obvious split is found, returns ("", original_text).
     """
     raw = (text or "").strip()
     if not raw:
         return "", ""
 
-    # Common pattern: "QUESTION: ... USER: ..."
-    m = re.search(
-        r"(?is)^(.*?)(?:user|question|prompt)\s*:\s*(.+)$",
-        raw,
-    )
+    # Pattern like:
+    # CONTEXT: ...
+    # USER: ...
+    m = re.search(r"(?is)^(.*?)(?:\buser\b|\bprompt\b|\bmessage\b)\s*:\s*(.+)$", raw)
     if m:
-        prefix = (m.group(1) or "").strip()
-        message = (m.group(2) or "").strip()
-        return prefix, message
+        hidden = (m.group(1) or "").strip()
+        user = (m.group(2) or "").strip()
+        return hidden, user
 
     return "", raw
 
 
+def _extract_options(text: str) -> List[str]:
+    if not text:
+        return []
+
+    lines = [line.strip() for line in text.splitlines() if line.strip()]
+    options: List[str] = []
+
+    for line in lines:
+        if re.match(r"^[A-E][\)\.\:]\s*", line, flags=re.I):
+            options.append(re.sub(r"^[A-E][\)\.\:]\s*", "", line, flags=re.I).strip())
+
+    if options:
+        return options
+
+    # fallback: inline A) ... B) ...
+    matches = re.findall(r"(?:^|\s)([A-E])[\)\.\:]\s*(.*?)(?=(?:\s+[A-E][\)\.\:])|$)", text, flags=re.I | re.S)
+    if matches:
+        return [m[1].strip() for m in matches if m[1].strip()]
+
+    return []
+
+
 def extract_game_context_fields(text: str) -> Dict[str, Any]:
     """
-    Lightweight parser for structured context coming from Unity / study messages.
-
-    Returns a dict with whatever fields can be detected.
-    Safe fallback: missing fields just remain absent.
+    Extracts lightweight structured fields from hidden Unity/game context.
+    Always returns stable keys expected by app.py.
     """
     raw = (text or "").strip()
-    lower = raw.lower()
 
-    fields: Dict[str, Any] = {}
+    result: Dict[str, Any] = {
+        "question": "",
+        "options": [],
+        "difficulty": None,
+        "category": None,
+        "money": None,
+        "has_choices": False,
+        "looks_like_quant": False,
+    }
 
-    # Money / balance
-    money_match = re.search(r"\b(?:money|balance|bank)\s*[:=]\s*([\-]?\d+(?:\.\d+)?)", raw, flags=re.I)
-    if money_match:
-        try:
-            fields["money"] = float(money_match.group(1))
-        except Exception:
-            pass
+    if not raw:
+        return result
 
-    # Difficulty
+    # question
+    q_match = re.search(r"\bquestion\s*[:=]\s*(.+?)(?=\n[A-Za-z_ ]+\s*[:=]|\Z)", raw, flags=re.I | re.S)
+    if q_match:
+        result["question"] = q_match.group(1).strip()
+
+    # options block
+    opt_match = re.search(r"\b(?:options|choices|answers)\s*[:=]\s*(.+?)(?=\n[A-Za-z_ ]+\s*[:=]|\Z)", raw, flags=re.I | re.S)
+    if opt_match:
+        result["options"] = _extract_options(opt_match.group(1))
+
+    # if no explicit options block, scan whole context
+    if not result["options"]:
+        result["options"] = _extract_options(raw)
+
+    result["has_choices"] = len(result["options"]) > 0
+
+    # difficulty
     difficulty_match = re.search(r"\bdifficulty\s*[:=]\s*([A-Za-z0-9_\- ]+)", raw, flags=re.I)
     if difficulty_match:
-        fields["difficulty"] = difficulty_match.group(1).strip()
+        result["difficulty"] = difficulty_match.group(1).strip()
 
-    # Category / topic
+    # category/topic
     category_match = re.search(r"\b(?:category|topic)\s*[:=]\s*([A-Za-z0-9_\- /]+)", raw, flags=re.I)
     if category_match:
-        fields["category"] = category_match.group(1).strip()
-
-    # Question text
-    question_match = re.search(r"\bquestion\s*[:=]\s*(.+)", raw, flags=re.I)
-    if question_match:
-        q = question_match.group(1).strip()
-        if q:
-            fields["question_text"] = q
-
-    # Answer choices in a rough form
-    if re.search(r"\bA[\)\.\:]", raw) and re.search(r"\bB[\)\.\:]", raw):
-        fields["has_choices"] = True
-
-    # Cheap flags
-    fields["looks_like_quant"] = any(
-        token in lower for token in ["solve", "equation", "percent", "%", "ratio", "probability", "mean", "median"]
+        result["category"] = category_match.group(1).strip()
+
+    # money/balance
+    money_match = re.search(r"\b(?:money|balance|bank)\s*[:=]\s*([\-]?\d+(?:\.\d+)?)", raw, flags=re.I)
+    if money_match:
+        try:
+            result["money"] = float(money_match.group(1))
+        except Exception:
+            pass
+
+    lower = raw.lower()
+    result["looks_like_quant"] = any(
+        token in lower
+        for token in [
+            "solve",
+            "equation",
+            "percent",
+            "%",
+            "ratio",
+            "probability",
+            "mean",
+            "median",
+            "algebra",
+            "integer",
+            "triangle",
+            "circle",
+        ]
     )
 
-    return fields
+    return result
 
 
-def detect_intent(text: str) -> str:
+def detect_intent(text: str, incoming_help_mode: Optional[str] = None) -> str:
+    """
+    Returns one of:
+    answer, hint, instruction, walkthrough, explain, method, definition, concept
+    """
+    forced = (incoming_help_mode or "").strip().lower()
+    if forced in {
+        "answer",
+        "hint",
+        "instruction",
+        "walkthrough",
+        "step_by_step",
+        "explain",
+        "method",
+        "definition",
+        "concept",
+    }:
+        return forced
+
     t = (text or "").strip().lower()
 
     if not t: