Create conversation_logic.py

conversation_logic.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from context_parser import (
+    mentions_choice_letter,
+    parse_hidden_context,
+    user_is_referring_to_existing_question,
+)
+from formatting import format_reply
+from models import SolverResult
+from quant_solver import extract_choices, is_quant_question, solve_quant
+
+
+def build_choice_explanation(chosen_letter: str, result: SolverResult, choices: dict[str, str], help_mode: str) -> str:
+    choice_text = choices.get(chosen_letter, "").strip()
+    value_text = result.answer_value.strip() if result.answer_value else ""
+
+    if help_mode == "hint":
+        if value_text and choice_text:
+            return f"Work out the value first, then compare it with choice {chosen_letter} ({choice_text})."
+        if choice_text:
+            return f"Focus on why choice {chosen_letter} fits the calculation better than the others."
+        return f"Focus on why choice {chosen_letter} matches the calculation."
+
+    if help_mode == "walkthrough":
+        if value_text and choice_text:
+            return (
+                f"The calculation gives {value_text}.\n"
+                f"Choice {chosen_letter} is {choice_text}, so it matches.\n"
+                f"That is why {chosen_letter} is the correct answer."
+            )
+        if choice_text:
+            return f"Choice {chosen_letter} matches the result of the calculation, so that is why it is correct."
+        return f"The solved result matches choice {chosen_letter}, so that is why it is correct."
+
+    if value_text and choice_text:
+        return f"Yes — it’s {chosen_letter}, because the calculation gives {value_text}, and choice {chosen_letter} is {choice_text}."
+    if choice_text:
+        return f"Yes — it’s {chosen_letter}, because that option matches the result."
+    return f"Yes — it’s {chosen_letter}."
+
+
+def handle_conversational_followup(ctx, help_mode: str):
+    user_text = ctx.visible_user_text
+    lower = user_text.lower().strip()
+    question_block = ctx.combined_question_block
+
+    if not question_block:
+        return None
+
+    if not user_is_referring_to_existing_question(user_text, ctx.question_text):
+        return None
+
+    solved = solve_quant(question_block, "answer")
+
+    asked_letter = mentions_choice_letter(user_text)
+    choices = extract_choices(question_block)
+
+    if asked_letter and solved.answer_letter and asked_letter == solved.answer_letter:
+        reply = build_choice_explanation(asked_letter, solved, choices, help_mode)
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=solved.solved,
+            help_mode=help_mode,
+            answer_letter=solved.answer_letter,
+            answer_value=solved.answer_value,
+        )
+
+    if asked_letter and solved.answer_letter and asked_letter != solved.answer_letter:
+        correct_choice_text = choices.get(solved.answer_letter, "").strip()
+        if help_mode == "hint":
+            reply = f"Check the calculation again and compare your result with choice {solved.answer_letter}, not {asked_letter}."
+        elif help_mode == "walkthrough":
+            reply = (
+                f"It is not {asked_letter}.\n"
+                f"The calculation leads to choice {solved.answer_letter}"
+                + (f", which is {correct_choice_text}." if correct_choice_text else ".")
+            )
+        else:
+            reply = f"It is not {asked_letter} — the correct choice is {solved.answer_letter}."
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=solved.solved,
+            help_mode=help_mode,
+            answer_letter=solved.answer_letter,
+            answer_value=solved.answer_value,
+        )
+
+    if lower in {"help", "can you help", "help me", "i dont get it", "i don't get it"}:
+        if help_mode == "hint":
+            reply = solve_quant(question_block, "hint").reply
+        elif help_mode == "walkthrough":
+            reply = solve_quant(question_block, "walkthrough").reply
+        else:
+            reply = solve_quant(question_block, "answer").reply
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=solved.solved,
+            help_mode=help_mode,
+            answer_letter=solved.answer_letter,
+            answer_value=solved.answer_value,
+        )
+
+    if "first step" in lower or "how do i start" in lower or "what do i do first" in lower:
+        hint_result = solve_quant(question_block, "hint")
+        return SolverResult(
+            reply=hint_result.reply,
+            domain="quant",
+            solved=hint_result.solved,
+            help_mode="hint",
+            answer_letter=hint_result.answer_letter,
+            answer_value=hint_result.answer_value,
+        )
+
+    if "why" in lower or "explain" in lower:
+        walkthrough_result = solve_quant(question_block, "walkthrough")
+        if solved.answer_letter and "why is it" not in lower:
+            choices = extract_choices(question_block)
+            choice_text = choices.get(solved.answer_letter, "").strip()
+            if choice_text:
+                extra = f"\n\nSo the correct choice is {solved.answer_letter} ({choice_text})."
+            else:
+                extra = f"\n\nSo the correct choice is {solved.answer_letter}."
+            walkthrough_result.reply += extra
+        return walkthrough_result
+
+    if "hint" in lower:
+        return solve_quant(question_block, "hint")
+
+    if "answer" in lower or "which one" in lower or "are you sure" in lower:
+        return solve_quant(question_block, "answer")
+
+    return None
+
+
+def solve_verbal_or_general(user_text: str, help_mode: str) -> SolverResult:
+    lower = user_text.lower()
+
+    if any(k in lower for k in ["sentence correction", "grammar", "verbal", "critical reasoning", "reading comprehension"]):
+        if help_mode == "hint":
+            reply = (
+                "First identify the task:\n"
+                "- Sentence Correction: grammar + meaning\n"
+                "- Critical Reasoning: conclusion, evidence, assumption\n"
+                "- Reading Comprehension: passage role, inference, detail"
+            )
+        elif help_mode == "walkthrough":
+            reply = (
+                "I can help verbally too, but for now this backend is strongest on quant-style items. "
+                "For verbal, I’d use elimination based on grammar, logic, scope, or passage support."
+            )
+        else:
+            reply = "I can help with verbal strategy, but this version is strongest on quant-style questions right now."
+
+        return SolverResult(reply=reply, domain="verbal", solved=False, help_mode=help_mode)
+
+    if help_mode == "hint":
+        reply = "I can help. Ask for a hint, an explanation, or the answer, and I’ll use the current in-game question context when available."
+    elif help_mode == "walkthrough":
+        reply = "I can talk it through step by step using the current in-game question context."
+    else:
+        reply = "Send a message naturally and I’ll respond using the current question context."
+
+    return SolverResult(reply=reply, domain="fallback", solved=False, help_mode=help_mode)
+
+
+def generate_response(
+    raw_user_text: str,
+    tone: float,
+    verbosity: float,
+    transparency: float,
+    help_mode: str,
+) -> SolverResult:
+    ctx = parse_hidden_context(raw_user_text)
+    visible_user_text = ctx.visible_user_text.strip()
+    question_block = ctx.combined_question_block.strip()
+
+    if not raw_user_text.strip():
+        result = SolverResult(
+            reply="Ask a question and I’ll help using the current in-game context.",
+            domain="fallback",
+            solved=False,
+            help_mode=help_mode,
+        )
+        result.reply = format_reply(result.reply, tone, verbosity, transparency, help_mode)
+        return result
+
+    followup = handle_conversational_followup(ctx, help_mode)
+    if followup is not None:
+        followup.reply = format_reply(followup.reply, tone, verbosity, transparency, followup.help_mode)
+        return followup
+
+    if question_block and is_quant_question(question_block):
+        result = solve_quant(question_block, help_mode)
+        result.reply = format_reply(result.reply, tone, verbosity, transparency, help_mode)
+        return result
+
+    if is_quant_question(visible_user_text):
+        result = solve_quant(visible_user_text, help_mode)
+        result.reply = format_reply(result.reply, tone, verbosity, transparency, help_mode)
+        return result
+
+    result = solve_verbal_or_general(visible_user_text or raw_user_text, help_mode)
+    result.reply = format_reply(result.reply, tone, verbosity, transparency, help_mode)
+    return result