Update conversation_logic.py

conversation_logic.py

@@ -2,49 +2,96 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional
 
-from context_parser import intent_to_help_mode
 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 retrieval_engine import RetrievalEngine
-from utils import short_lines
 
 
 def _teaching_lines(chunks: List[RetrievedChunk]) -> List[str]:
-    lines = []
+    lines: List[str] = []
     for chunk in chunks:
-        text = chunk.text.strip().replace("\n", " ")
+        text = (chunk.text or "").strip().replace("\n", " ")
         if len(text) > 220:
             text = text[:217].rstrip() + "…"
-        lines.append(f"- {chunk.topic}: {text}")
+        topic = chunk.topic or "general"
+        lines.append(f"- {topic}: {text}")
     return lines
 
 
-def _compose_quant_reply(result: SolverResult, intent: str, reveal_answer: bool, verbosity: float) -> str:
+def _should_retrieve(intent: str, result: SolverResult) -> bool:
+    if not result.solved:
+        return True
+    return intent in {"hint", "method", "step_by_step", "full_working", "walkthrough", "explain"}
+
+
+def _retrieval_query(user_text: str, question_text: str, options_text: str) -> str:
+    parts = []
+    if question_text.strip():
+        parts.append(question_text.strip())
+    if options_text.strip():
+        parts.append(options_text.strip())
+    if user_text.strip():
+        parts.append(user_text.strip())
+    return "\n".join(parts).strip()
+
+
+def _compose_quant_reply(
+    result: SolverResult,
+    intent: str,
+    reveal_answer: bool,
+    verbosity: float,
+) -> str:
     steps = result.steps or []
-    internal = result.internal_answer or result.answer_value or ""
+    internal = (
+        getattr(result, "internal_answer", None)
+        or getattr(result, "internal_answer_value", None)
+        or getattr(result, "answer_value", None)
+        or ""
+    )
 
     if intent == "hint":
-        return steps[0] if steps else "Start by translating the wording into an equation."
-
-    if intent == "method":
-        body = "Use this method:\n" + "\n".join(f"- {s}" for s in steps[:3])
+        if steps:
+            return f"Hint:\n- {steps[0]}"
+        return "Hint:\n- Start by translating the wording into an equation."
+
+    if intent in {"method", "walkthrough"}:
+        body = "Use this method:"
+        if steps:
+            limit = 3 if verbosity < 0.75 else 4
+            body += "\n" + "\n".join(f"- {s}" for s in steps[:limit])
+        else:
+            body += "\n- Treat the statement as an equation.\n- Isolate the unknown step by step."
         if reveal_answer and internal:
-            body += f"\n\nInternal result: {internal}."
+            body += f"\n\nThat gives {internal}."
         return body
 
     if intent in {"step_by_step", "full_working"}:
-        body = "\n".join(f"{i+1}. {s}" for i, s in enumerate(steps[:4])) if steps else "Work through the algebra one step at a time."
+        if steps:
+            limit = 4 if verbosity < 0.75 else min(6, len(steps))
+            body = "\n".join(f"{i+1}. {s}" for i, s in enumerate(steps[:limit]))
+        else:
+            body = "1. Translate the wording into an equation.\n2. Isolate the variable carefully.\n3. Check the result."
         if reveal_answer and internal:
             body += f"\n\nSo the result is {internal}."
         return body
 
+    if intent == "explain":
+        if steps:
+            body = "Here is the idea:\n" + "\n".join(f"- {s}" for s in steps[:3])
+        else:
+            body = "Here is the idea:\n- Turn the wording into a clear mathematical relationship.\n- Solve it step by step."
+        if reveal_answer and internal:
+            body += f"\n\nThat leads to {internal}."
+        return body
+
     if reveal_answer and internal:
         return f"The result is {internal}."
 
     if steps:
         return "\n".join(f"- {s}" for s in steps[:2])
+
     return result.reply or "I can help solve this, but I need a little more structure from the question."
 
 
@@ -67,34 +114,52 @@ class ConversationEngine:
         retrieval_context: str = "",
     ) -> SolverResult:
         user_text = (raw_user_text or "").strip()
-        question_block = "\n".join([x for x in [question_text.strip(), options_text.strip()] if x]).strip()
-        solver_input = user_text or question_text or question_block
+        question_text = (question_text or "").strip()
+        options_text = (options_text or "").strip()
 
-        if is_quant_question(solver_input) or (question_text and is_quant_question(question_text)):
-            result = solve_quant(solver_input if is_quant_question(solver_input) else question_text)
+        question_block = "\n".join([x for x in [question_text, options_text] if x]).strip()
+        solver_input = user_text or question_block or question_text
+
+        quant_from_user = bool(user_text and is_quant_question(user_text))
+        quant_from_question = bool(question_text and is_quant_question(question_block or question_text))
+
+        if quant_from_user or quant_from_question:
+            solve_text = user_text if quant_from_user else (question_block or question_text)
+            result = solve_quant(solve_text)
             result.help_mode = help_mode
+
             reveal_answer = intent in {"answer", "full_working"} or transparency >= 0.85
 
-            if result.topic:
-                chunks = self.retriever.search(question_text or user_text, topic=result.topic, intent=intent, k=3)
-            else:
-                chunks = self.retriever.search(question_text or user_text, topic="general", intent=intent, k=3)
+            chunks: List[RetrievedChunk] = []
+            if _should_retrieve(intent, result):
+                topic = result.topic or getattr(result, "detected_topic", None) or "general"
+                query = _retrieval_query(user_text, question_text, options_text)
+                chunks = self.retriever.search(query, topic=topic, intent=intent, k=3)
+
             result.teaching_chunks = chunks
             result.used_retrieval = bool(chunks)
 
-            core = _compose_quant_reply(result, intent, reveal_answer=reveal_answer, verbosity=verbosity)
-            if chunks and intent in {"hint", "method", "step_by_step", "full_working"}:
+            core = _compose_quant_reply(
+                result,
+                intent=intent,
+                reveal_answer=reveal_answer,
+                verbosity=verbosity,
+            )
+
+            if chunks and intent in {"hint", "method", "step_by_step", "full_working", "walkthrough", "explain"}:
                 core += "\n\nRelevant study notes:\n" + "\n".join(_teaching_lines(chunks))
+
             result.reply = format_reply(core, tone, verbosity, transparency, help_mode)
             return result
 
-        # Non-quant conversational support
         result = SolverResult(domain="general", solved=False, help_mode=help_mode)
+
         prompt = (
             "You are a helpful study assistant. Reply naturally and briefly. "
             "Do not invent facts. If the user is asking for emotional support or general help, be supportive and practical.\n\n"
             f"User message: {user_text}"
         )
+
         generated = self.generator.generate(prompt) if self.generator and self.generator.available() else None
         if generated:
             result.reply = format_reply(generated, tone, verbosity, transparency, help_mode)
@@ -103,4 +168,4 @@ class ConversationEngine:
 
         fallback = "I can help with the current question, explain a method, or talk through the next step."
         result.reply = format_reply(fallback, tone, verbosity, transparency, help_mode)
-        return result
+        return result