Update conversation_logic.py

conversation_logic.py

@@ -8,8 +8,8 @@ from formatting import format_reply
 from generator_engine import GeneratorEngine
 from models import RetrievedChunk, SolverResult
 from quant_solver import is_quant_question, solve_quant
+from question_classifier import classify_question
 from retrieval_engine import RetrievalEngine
-from utils import short_lines
 
 
 RETRIEVAL_ALLOWED_INTENTS = {
@@ -56,6 +56,30 @@ STRUCTURE_KEYWORDS = {
     "number_properties": [
         "integer", "odd", "even", "prime", "divisible", "factor", "multiple",
     ],
+    "number_theory": [
+        "integer", "odd", "even", "prime", "divisible", "factor", "multiple", "remainder",
+    ],
+    "sequence": [
+        "sequence", "geometric", "arithmetic", "term", "series",
+    ],
+    "quant": [
+        "equation", "solve", "value", "integer", "ratio", "percent",
+    ],
+    "data": [
+        "data", "mean", "median", "trend", "chart", "table", "correlation",
+    ],
+    "verbal": [
+        "grammar", "meaning", "author", "argument", "sentence", "word",
+    ],
+    "reasoning": [
+        "argument", "assume", "conclusion", "evidence", "author",
+    ],
+    "vocabulary": [
+        "meaning", "definition", "word", "closest in meaning",
+    ],
+    "grammar": [
+        "grammar", "sentence", "verb", "agreement", "idiom", "modifier",
+    ],
 }
 
 INTENT_KEYWORDS = {
@@ -80,6 +104,7 @@ MISMATCH_TERMS = {
     "probability": ["absolute value", "circle area", "quadratic"],
     "geometry": ["absolute value", "prime", "median salary"],
     "number_properties": ["circle", "triangle", "absolute value"],
+    "number_theory": ["circle", "triangle", "median salary"],
 }
 
 
@@ -94,27 +119,29 @@ def _teaching_lines(chunks: List[RetrievedChunk]) -> List[str]:
     return lines
 
 
-def _compose_quant_reply(
+def _compose_reply(
     result: SolverResult,
     intent: str,
     reveal_answer: bool,
     verbosity: float,
+    category: Optional[str] = None,
+    question_type: Optional[str] = None,
 ) -> str:
     steps = result.steps or []
     internal = result.internal_answer or result.answer_value or ""
 
     if intent == "hint":
-        return steps[0] if steps else "Start by translating the wording into an equation."
+        return steps[0] if steps else "Start by identifying what the question is really asking."
 
     if intent == "instruction":
         if steps:
             return f"First step: {steps[0]}"
-        return "First, turn the wording into a mathematical relationship."
+        return "First, identify the key relationship or comparison in the question."
 
     if intent == "definition":
         if steps:
             return f"Here is the idea in context:\n- {steps[0]}"
-        return "This is asking for the meaning of the term or operation in the problem."
+        return "This is asking for the meaning of the term or idea in the question."
 
     if intent in {"walkthrough", "step_by_step", "explain", "method", "concept"}:
         if not steps:
@@ -139,6 +166,12 @@ def _compose_quant_reply(
     if steps:
         return steps[0]
 
+    if category == "Verbal":
+        return "I can help analyse the wording or logic, but I do not have a full verbal solver yet."
+
+    if category == "DataInsight":
+        return "I can help reason through the data, but I cannot confidently solve this from the current parse alone yet."
+
     return "I can help with this, but I cannot confidently solve it from the current parse alone yet."
 
 
@@ -156,12 +189,15 @@ def _extract_keywords(text: str) -> Set[str]:
     return {w for w in raw if len(w) > 2 and w not in stop}
 
 
-def _infer_structure_terms(question_text: str, topic: Optional[str]) -> List[str]:
+def _infer_structure_terms(question_text: str, topic: Optional[str], question_type: Optional[str]) -> List[str]:
     terms: List[str] = []
 
     if topic and topic in STRUCTURE_KEYWORDS:
         terms.extend(STRUCTURE_KEYWORDS[topic])
 
+    if question_type:
+        terms.extend(question_type.replace("_", " ").split())
+
     q = (question_text or "").lower()
 
     if "=" in q:
@@ -174,6 +210,14 @@ def _infer_structure_terms(question_text: str, topic: Optional[str]) -> List[str
         terms.extend(["multiply", "undo operations"])
     if "%" in q or "percent" in q:
         terms.extend(["percent", "percentage"])
+    if "ratio" in q:
+        terms.extend(["ratio", "proportion"])
+    if "mean" in q or "average" in q:
+        terms.extend(["mean", "average"])
+    if "median" in q:
+        terms.extend(["median"])
+    if "probability" in q:
+        terms.extend(["probability"])
 
     return list(dict.fromkeys(terms))
 
@@ -204,9 +248,11 @@ def _is_direct_solve_request(text: str, intent: str) -> bool:
     return False
 
 
-def should_retrieve(intent: str, solved: bool, raw_user_text: str) -> bool:
+def should_retrieve(intent: str, solved: bool, raw_user_text: str, category: Optional[str] = None) -> bool:
     if intent in RETRIEVAL_ALLOWED_INTENTS:
         return True
+    if not solved and category in {"Verbal", "DataInsight"}:
+        return True
     if not solved:
         return True
     if _is_direct_solve_request(raw_user_text, intent):
@@ -219,6 +265,7 @@ def _score_chunk(
     intent: str,
     topic: Optional[str],
     question_text: str,
+    question_type: Optional[str] = None,
 ) -> float:
     text = f"{chunk.topic} {chunk.text}".lower()
     score = 0.0
@@ -230,7 +277,7 @@ def _score_chunk(
         elif topic.lower() in text:
             score += 2.0
 
-    for term in _infer_structure_terms(question_text, topic):
+    for term in _infer_structure_terms(question_text, topic, question_type):
         if term.lower() in text:
             score += 1.5
 
@@ -253,13 +300,14 @@ def _filter_retrieved_chunks(
     intent: str,
     topic: Optional[str],
     question_text: str,
+    question_type: Optional[str] = None,
     min_score: float = 2.5,
     max_chunks: int = 3,
 ) -> List[RetrievedChunk]:
     scored: List[tuple[float, RetrievedChunk]] = []
 
     for chunk in chunks:
-        s = _score_chunk(chunk, intent, topic, question_text)
+        s = _score_chunk(chunk, intent, topic, question_text, question_type)
         if s >= min_score:
             scored.append((s, chunk))
 
@@ -273,6 +321,8 @@ def _build_retrieval_query(
     intent: str,
     topic: Optional[str],
     solved: bool,
+    question_type: Optional[str] = None,
+    category: Optional[str] = None,
 ) -> str:
     parts: List[str] = []
 
@@ -280,9 +330,15 @@ def _build_retrieval_query(
     if base:
         parts.append(base)
 
+    if category:
+        parts.append(category)
+
     if topic:
         parts.append(topic)
 
+    if question_type:
+        parts.append(question_type.replace("_", " "))
+
     if intent in {"definition", "concept"}:
         parts.append("definition concept explanation")
     elif intent in {"walkthrough", "step_by_step", "method", "instruction"}:
@@ -324,6 +380,15 @@ class ConversationEngine:
         solver_input = (question_text or raw_user_text or "").strip()
         user_text = (raw_user_text or "").strip()
 
+        category = kwargs.get("category")
+        classification = classify_question(
+            question_text=solver_input,
+            category=category,
+        )
+        question_topic = classification.get("topic")
+        question_type = classification.get("type")
+        inferred_category = classification.get("category") or category
+
         resolved_intent = intent or detect_intent(user_text, help_mode)
         resolved_help_mode = help_mode or intent_to_help_mode(resolved_intent)
         reveal_answer = resolved_help_mode == "answer" or transparency >= 0.8
@@ -334,7 +399,7 @@ class ConversationEngine:
             help_mode=resolved_help_mode,
             answer_letter=None,
             answer_value=None,
-            topic=None,
+            topic=question_topic,
             used_retrieval=False,
             used_generator=False,
             internal_answer=None,
@@ -345,23 +410,28 @@ class ConversationEngine:
 
         selected_chunks: List[RetrievedChunk] = []
 
-        if is_quant_question(solver_input):
+        if inferred_category == "Quantitative" or is_quant_question(solver_input):
             solved_result = solve_quant(solver_input)
             if solved_result is not None:
                 result = solved_result
             result.help_mode = resolved_help_mode
+            if not result.topic:
+                result.topic = question_topic
 
-        reply = _compose_quant_reply(
+        reply = _compose_reply(
             result=result,
             intent=resolved_intent,
             reveal_answer=reveal_answer,
             verbosity=verbosity,
+            category=inferred_category,
+            question_type=question_type,
         )
 
         allow_retrieval = should_retrieve(
             intent=resolved_intent,
             solved=bool(result.solved),
             raw_user_text=user_text or solver_input,
+            category=inferred_category,
         )
 
         if allow_retrieval and retrieval_context:
@@ -370,6 +440,7 @@ class ConversationEngine:
                 intent=resolved_intent,
                 topic=result.topic,
                 question_text=solver_input,
+                question_type=question_type,
             )
             if filtered:
                 selected_chunks = filtered
@@ -384,6 +455,8 @@ class ConversationEngine:
                     intent=resolved_intent,
                     topic=result.topic,
                     solved=bool(result.solved),
+                    question_type=question_type,
+                    category=inferred_category,
                 ),
                 top_k=6,
             )
@@ -392,6 +465,7 @@ class ConversationEngine:
                 intent=resolved_intent,
                 topic=result.topic,
                 question_text=solver_input,
+                question_type=question_type,
             )
             if filtered:
                 selected_chunks = filtered
@@ -423,6 +497,9 @@ class ConversationEngine:
             "intent": resolved_intent,
             "question_text": question_text or "",
             "options_count": len(options_text or []),
+            "category": inferred_category,
+            "question_type": question_type,
+            "classified_topic": question_topic,
         }
 
         return result