Create app.py

app.py

@@ -1,30 +1,19 @@
-# app.py
 from __future__ import annotations
 
-import ast
-import json
-import math
 import os
-import re
-from dataclasses import dataclass
-from statistics import mean, median
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict
 
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse, JSONResponse
-from pydantic import BaseModel
 
-try:
-    import sympy as sp
-except Exception:
-    sp = None
+from context_parser import detect_help_mode
+from conversation_logic import generate_response
+from models import ChatRequest
+from ui_html import HOME_HTML
+from utils import clamp01, get_user_text
 
 
-# =========================================================
-# App setup
-# =========================================================
-
 app = FastAPI(title="GMAT Solver v3", version="3.0.0")
 
 app.add_middleware(
@@ -36,978 +25,6 @@ app.add_middleware(
 )
 
 
-# =========================================================
-# Request / response models
-# =========================================================
-
-class ChatRequest(BaseModel):
-    message: Optional[str] = None
-    prompt: Optional[str] = None
-    query: Optional[str] = None
-    text: Optional[str] = None
-    user_message: Optional[str] = None
-
-    tone: Optional[float] = 0.5
-    verbosity: Optional[float] = 0.5
-    transparency: Optional[float] = 0.5
-
-    help_mode: Optional[str] = "answer"
-    history: Optional[List[Dict[str, Any]]] = None
-
-
-# =========================================================
-# Data classes
-# =========================================================
-
-@dataclass
-class SolverResult:
-    reply: str
-    domain: str
-    solved: bool
-    help_mode: str
-    answer_letter: Optional[str] = None
-    answer_value: Optional[str] = None
-
-
-@dataclass
-class ParsedContext:
-    raw_message: str
-    visible_user_text: str
-    full_context_text: str
-    question_text: str
-    options_text: str
-    combined_question_block: str
-    recent_conversation: str
-
-
-# =========================================================
-# Utilities
-# =========================================================
-
-CHOICE_LETTERS = ["A", "B", "C", "D", "E"]
-
-
-def clamp01(x: Any, default: float = 0.5) -> float:
-    try:
-        v = float(x)
-        return max(0.0, min(1.0, v))
-    except Exception:
-        return default
-
-
-def normalize_spaces(text: str) -> str:
-    return re.sub(r"\s+", " ", text).strip()
-
-
-def clean_math_text(text: str) -> str:
-    t = text
-    t = t.replace("×", "*").replace("÷", "/").replace("–", "-").replace("—", "-")
-    t = t.replace("−", "-").replace("^", "**")
-    return t
-
-
-def extract_text_from_any_payload(payload: Any) -> str:
-    if payload is None:
-        return ""
-
-    if isinstance(payload, str):
-        s = payload.strip()
-
-        if (s.startswith("{") and s.endswith("}")) or (s.startswith("[") and s.endswith("]")):
-            try:
-                decoded = json.loads(s)
-                return extract_text_from_any_payload(decoded)
-            except Exception:
-                pass
-
-        try:
-            decoded = ast.literal_eval(s)
-            if isinstance(decoded, (dict, list)):
-                return extract_text_from_any_payload(decoded)
-        except Exception:
-            pass
-
-        return s
-
-    if isinstance(payload, dict):
-        for key in [
-            "message", "prompt", "query", "text", "user_message",
-            "input", "data", "payload", "body", "content"
-        ]:
-            if key in payload:
-                extracted = extract_text_from_any_payload(payload[key])
-                if extracted:
-                    return extracted
-
-        strings: List[str] = []
-        for v in payload.values():
-            if isinstance(v, (str, dict, list)):
-                maybe = extract_text_from_any_payload(v)
-                if maybe:
-                    strings.append(maybe)
-        return "\n".join(strings).strip()
-
-    if isinstance(payload, list):
-        parts = [extract_text_from_any_payload(x) for x in payload]
-        return "\n".join([p for p in parts if p]).strip()
-
-    return str(payload).strip()
-
-
-def get_user_text(req: ChatRequest, raw_body: Any = None) -> str:
-    for field in ["message", "prompt", "query", "text", "user_message"]:
-        value = getattr(req, field, None)
-        if isinstance(value, str) and value.strip():
-            return value.strip()
-
-    return extract_text_from_any_payload(raw_body).strip()
-
-
-def style_prefix(tone: float) -> str:
-    if tone < 0.33:
-        return "Let’s solve it efficiently."
-    if tone < 0.66:
-        return "Let’s work through it."
-    return "You’ve got this — let’s solve it cleanly."
-
-
-def format_reply(core: str, tone: float, verbosity: float, transparency: float, help_mode: str) -> str:
-    prefix = style_prefix(tone)
-
-    if help_mode == "hint":
-        if transparency < 0.4:
-            return f"{prefix}\n\nHint: {core}"
-        return f"{prefix}\n\nHint:\n{core}"
-
-    if help_mode == "walkthrough":
-        if verbosity < 0.35:
-            return f"{prefix}\n\n{core}"
-        return f"{prefix}\n\nWalkthrough:\n{core}"
-
-    if verbosity < 0.33:
-        return f"{prefix}\n\n{core}"
-
-    if transparency >= 0.5:
-        return f"{prefix}\n\n{core}"
-
-    return f"{prefix}\n\n{core}"
-
-
-def has_answer_choices(text: str) -> bool:
-    patterns = [
-        r"\bA[\)\.\:]",
-        r"\bB[\)\.\:]",
-        r"\bC[\)\.\:]",
-        r"\bD[\)\.\:]",
-        r"\bE[\)\.\:]",
-    ]
-    return sum(bool(re.search(p, text, flags=re.I)) for p in patterns) >= 3
-
-
-def extract_choices(text: str) -> Dict[str, str]:
-    matches = list(
-        re.finditer(
-            r"(?im)(?:^|\n|\s)([A-E])[\)\.\:]\s*(.*?)(?=(?:\n?\s*[A-E][\)\.\:]\s)|$)",
-            text,
-        )
-    )
-    choices: Dict[str, str] = {}
-    for m in matches:
-        letter = m.group(1).upper()
-        content = normalize_spaces(m.group(2))
-        choices[letter] = content
-    return choices
-
-
-def extract_numbers(text: str) -> List[float]:
-    nums = re.findall(r"-?\d+(?:\.\d+)?", text.replace(",", ""))
-    out: List[float] = []
-    for n in nums:
-        try:
-            out.append(float(n))
-        except Exception:
-            pass
-    return out
-
-
-def extract_section(text: str, start_label: str, end_labels: List[str]) -> str:
-    start_idx = text.find(start_label)
-    if start_idx == -1:
-        return ""
-
-    start_idx += len(start_label)
-    remaining = text[start_idx:]
-
-    end_positions = []
-    for label in end_labels:
-        idx = remaining.find(label)
-        if idx != -1:
-            end_positions.append(idx)
-
-    if end_positions:
-        end_idx = min(end_positions)
-        return remaining[:end_idx].strip()
-
-    return remaining.strip()
-
-
-def parse_hidden_context(message: str) -> ParsedContext:
-    raw = message or ""
-
-    visible_user_text = ""
-    question_text = ""
-    options_text = ""
-    recent_conversation = ""
-
-    if "Latest player message:" in raw:
-        visible_user_text = extract_section(raw, "Latest player message:", [])
-    elif "Player message:" in raw:
-        visible_user_text = extract_section(raw, "Player message:", [])
-    else:
-        visible_user_text = raw.strip()
-
-    if "Question:" in raw:
-        question_text = extract_section(
-            raw,
-            "Question:",
-            ["\nOptions:", "\nPlayer balance:", "\nLast outcome:", "\nRecent conversation:", "\nLatest player message:", "\nPlayer message:"]
-        )
-
-    if "Options:" in raw:
-        options_text = extract_section(
-            raw,
-            "Options:",
-            ["\nPlayer balance:", "\nLast outcome:", "\nRecent conversation:", "\nLatest player message:", "\nPlayer message:"]
-        )
-
-    if "Recent conversation:" in raw:
-        recent_conversation = extract_section(
-            raw,
-            "Recent conversation:",
-            ["\nLatest player message:", "\nPlayer message:"]
-        )
-
-    combined_parts = []
-    if question_text:
-        combined_parts.append(question_text.strip())
-    if options_text:
-        combined_parts.append(options_text.strip())
-
-    combined_question_block = "\n".join([p for p in combined_parts if p]).strip()
-    if not combined_question_block:
-        combined_question_block = raw.strip()
-
-    return ParsedContext(
-        raw_message=raw,
-        visible_user_text=visible_user_text.strip(),
-        full_context_text=raw.strip(),
-        question_text=question_text.strip(),
-        options_text=options_text.strip(),
-        combined_question_block=combined_question_block.strip(),
-        recent_conversation=recent_conversation.strip(),
-    )
-
-
-def detect_help_mode(user_text: str, supplied: Optional[str]) -> str:
-    lower = (user_text or "").lower().strip()
-
-    if supplied in {"hint", "walkthrough", "answer"}:
-        if lower not in {"hint", "walkthrough", "answer"}:
-            if "hint" in lower:
-                return "hint"
-            if "walkthrough" in lower or "step by step" in lower or "work through" in lower:
-                return "walkthrough"
-            if "explain" in lower and "why" in lower:
-                return "walkthrough"
-            return supplied
-        return supplied
-
-    if lower in {"hint", "just a hint", "hint please", "small hint"}:
-        return "hint"
-
-    if "hint" in lower:
-        return "hint"
-
-    if (
-        "walkthrough" in lower
-        or "step by step" in lower
-        or "work through" in lower
-        or "explain step by step" in lower
-    ):
-        return "walkthrough"
-
-    if "why" in lower or "explain" in lower:
-        return "walkthrough"
-
-    return "answer"
-
-
-def user_is_referring_to_existing_question(user_text: str, question_text: str) -> bool:
-    lower = (user_text or "").lower().strip()
-
-    if not question_text:
-        return False
-
-    short_refs = {
-        "help", "hint", "why", "why?", "explain", "explain it", "explain this",
-        "answer", "what's the answer", "what is the answer", "is it a", "is it b",
-        "is it c", "is it d", "is it e", "which one", "which option",
-        "what do i do first", "what do i do", "how do i start", "are you sure",
-        "can you help", "help me", "i don't get it", "i dont get it",
-        "why is it c", "why is it b", "why is it a", "why is it d", "why is it e"
-    }
-
-    if lower in short_refs:
-        return True
-
-    if len(lower) <= 25 and any(phrase in lower for phrase in [
-        "is it ", "why", "hint", "explain", "answer", "help", "first step"
-    ]):
-        return True
-
-    return False
-
-
-def mentions_choice_letter(user_text: str) -> Optional[str]:
-    lower = (user_text or "").lower().strip()
-    m = re.search(r"\b(?:is it|answer is|it's|its|option|choice)\s*([a-e])\b", lower)
-    if m:
-        return m.group(1).upper()
-
-    m = re.search(r"\bwhy is it\s*([a-e])\b", lower)
-    if m:
-        return m.group(1).upper()
-
-    if lower in {"a", "b", "c", "d", "e"}:
-        return lower.upper()
-
-    return None
-
-
-def is_quant_question(text: str) -> bool:
-    lower = text.lower()
-    quant_keywords = [
-        "solve", "equation", "integer", "percent", "percentage", "ratio", "probability",
-        "mean", "median", "average", "sum", "difference", "product", "quotient",
-        "triangle", "circle", "rectangle", "perimeter", "area", "volume",
-        "number line", "positive", "negative", "multiple", "factor", "prime",
-        "distance", "speed", "work", "mixture", "consecutive", "algebra",
-        "value of x", "value of y", "what is x", "what is y"
-    ]
-    if any(k in lower for k in quant_keywords):
-        return True
-    if re.search(r"[0-9]", text) and ("?" in text or has_answer_choices(text)):
-        return True
-    return False
-
-
-# =========================================================
-# Quant engine
-# =========================================================
-
-def try_eval_expression(expr: str) -> Optional[float]:
-    expr = clean_math_text(expr)
-    expr = expr.strip()
-    expr = expr.replace("%", "/100")
-    expr = re.sub(r"[^0-9\.\+\-\*\/\(\)\s]", "", expr)
-
-    if not expr:
-        return None
-
-    try:
-        return float(eval(expr, {"__builtins__": {}}, {}))
-    except Exception:
-        return None
-
-
-def parse_direct_expression_question(text: str) -> Optional[str]:
-    lower = text.lower()
-    m = re.search(
-        r"(?:what is|calculate|compute|evaluate|find)\s+([0-9\.\+\-\*\/\(\)\s]+)\??",
-        lower,
-    )
-    if not m:
-        return None
-    expr = m.group(1).strip()
-    if len(expr) < 1:
-        return None
-    return expr
-
-
-def solve_basic_expression(text: str, help_mode: str) -> Optional[SolverResult]:
-    expr = parse_direct_expression_question(text)
-    if not expr:
-        return None
-
-    value = try_eval_expression(expr)
-    if value is None:
-        return None
-
-    if help_mode == "hint":
-        reply = "Focus on order of operations: parentheses, multiplication/division, then addition/subtraction."
-    elif help_mode == "walkthrough":
-        reply = f"Evaluate the expression {expr} using order of operations.\nThat gives {value:g}."
-    else:
-        reply = f"The value is {value:g}."
-
-    return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{value:g}")
-
-
-def solve_percent_question(text: str, help_mode: str) -> Optional[SolverResult]:
-    lower = text.lower()
-
-    m = re.search(r"what is\s+(\d+(?:\.\d+)?)\s*%\s+of\s+(\d+(?:\.\d+)?)", lower)
-    if m:
-        p = float(m.group(1))
-        n = float(m.group(2))
-        ans = p / 100 * n
-
-        if help_mode == "hint":
-            reply = "Convert the percent to a decimal, then multiply."
-        elif help_mode == "walkthrough":
-            reply = f"{p}% of {n} = {p/100:g} × {n} = {ans:g}."
-        else:
-            reply = f"The answer is {ans:g}."
-
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
-
-    m = re.search(r"(\d+(?:\.\d+)?)\s+is\s+what percent of\s+(\d+(?:\.\d+)?)", lower)
-    if m:
-        x = float(m.group(1))
-        y = float(m.group(2))
-        if y == 0:
-            return None
-
-        ans = x / y * 100
-
-        if help_mode == "hint":
-            reply = "Use part ÷ whole × 100."
-        elif help_mode == "walkthrough":
-            reply = f"Percent = ({x} / {y}) × 100 = {ans:g}%."
-        else:
-            reply = f"The answer is {ans:g}%."
-
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}%")
-
-    m = re.search(
-        r"(\d+(?:\.\d+)?)\s+(?:is\s+)?(increased|decreased)\s+by\s+(\d+(?:\.\d+)?)\s*%",
-        lower,
-    )
-    if m:
-        base = float(m.group(1))
-        direction = m.group(2)
-        p = float(m.group(3)) / 100
-        ans = base * (1 + p) if direction == "increased" else base * (1 - p)
-
-        if help_mode == "hint":
-            reply = "Use multiplier form: increase → 1 + p, decrease → 1 - p."
-        elif help_mode == "walkthrough":
-            mult = 1 + p if direction == "increased" else 1 - p
-            reply = f"Multiplier = {mult:g}, so {base:g} × {mult:g} = {ans:g}."
-        else:
-            reply = f"The result is {ans:g}."
-
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
-
-    return None
-
-
-def solve_ratio_question(text: str, help_mode: str) -> Optional[SolverResult]:
-    lower = text.lower()
-
-    m = re.search(
-        r"ratio of .*? is\s+(\d+)\s*:\s*(\d+).*?total (?:is|of)\s+(\d+(?:\.\d+)?)",
-        lower
-    )
-    if not m:
-        m = re.search(
-            r"(\d+)\s*:\s*(\d+).*?total (?:is|of)\s+(\d+(?:\.\d+)?)",
-            lower
-        )
-
-    if m:
-        a = float(m.group(1))
-        b = float(m.group(2))
-        total = float(m.group(3))
-        parts = a + b
-        if parts == 0:
-            return None
-
-        first = total * a / parts
-        second = total * b / parts
-
-        if help_mode == "hint":
-            reply = "Add the ratio parts, then convert each part into a fraction of the total."
-        elif help_mode == "walkthrough":
-            reply = (
-                f"Total parts = {a:g} + {b:g} = {parts:g}.\n"
-                f"First quantity = {a:g}/{parts:g} × {total:g} = {first:g}.\n"
-                f"Second quantity = {b:g}/{parts:g} × {total:g} = {second:g}."
-            )
-        else:
-            reply = f"The two quantities are {first:g} and {second:g}."
-
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{first:g}, {second:g}")
-
-    return None
-
-
-def solve_average_question(text: str, help_mode: str) -> Optional[SolverResult]:
-    lower = text.lower()
-
-    if "mean" in lower or "average" in lower:
-        nums = extract_numbers(text)
-        if len(nums) >= 2:
-            ans = mean(nums)
-
-            if help_mode == "hint":
-                reply = "Add the numbers, then divide by how many there are."
-            elif help_mode == "walkthrough":
-                reply = f"The numbers are {', '.join(f'{x:g}' for x in nums)}.\nTheir average is {ans:g}."
-            else:
-                reply = f"The average is {ans:g}."
-
-            return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
-
-    if "median" in lower:
-        nums = extract_numbers(text)
-        if len(nums) >= 2:
-            ans = median(nums)
-
-            if help_mode == "hint":
-                reply = "Sort the numbers first, then take the middle value."
-            elif help_mode == "walkthrough":
-                s = sorted(nums)
-                reply = f"Sorted numbers: {', '.join(f'{x:g}' for x in s)}.\nThe median is {ans:g}."
-            else:
-                reply = f"The median is {ans:g}."
-
-            return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
-
-    return None
-
-
-def solve_probability_question(text: str, help_mode: str) -> Optional[SolverResult]:
-    lower = text.lower()
-
-    m = re.search(r"(\d+)\s+red.*?(\d+)\s+blue.*?probability", lower)
-    if m:
-        r = float(m.group(1))
-        b = float(m.group(2))
-        total = r + b
-        if total == 0:
-            return None
-
-        ans = r / total
-
-        if help_mode == "hint":
-            reply = "Probability = favorable outcomes ÷ total outcomes."
-        elif help_mode == "walkthrough":
-            reply = f"Favorable outcomes = {r:g}, total outcomes = {total:g}, so probability = {r:g}/{total:g} = {ans:g}."
-        else:
-            reply = f"The probability is {ans:g}."
-
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
-
-    return None
-
-
-def solve_geometry_question(text: str, help_mode: str) -> Optional[SolverResult]:
-    lower = text.lower()
-
-    m = re.search(r"rectangle.*?length\s*(?:is|=)?\s*(\d+(?:\.\d+)?)\D+width\s*(?:is|=)?\s*(\d+(?:\.\d+)?)", lower)
-    if m and "area" in lower:
-        l = float(m.group(1))
-        w = float(m.group(2))
-        ans = l * w
-
-        if help_mode == "hint":
-            reply = "For a rectangle, area = length × width."
-        elif help_mode == "walkthrough":
-            reply = f"Area = {l:g} × {w:g} = {ans:g}."
-        else:
-            reply = f"The area is {ans:g}."
-
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
-
-    m = re.search(r"circle.*?radius\s*(?:is|=)?\s*(\d+(?:\.\d+)?)", lower)
-    if m and "area" in lower:
-        r = float(m.group(1))
-        ans = math.pi * r * r
-
-        if help_mode == "hint":
-            reply = "For a circle, area = πr²."
-        elif help_mode == "walkthrough":
-            reply = f"Area = π({r:g})² = {ans:.4f}."
-        else:
-            reply = f"The area is {ans:.4f}."
-
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:.4f}")
-
-    m = re.search(r"triangle.*?base\s*(?:is|=)?\s*(\d+(?:\.\d+)?)\D+height\s*(?:is|=)?\s*(\d+(?:\.\d+)?)", lower)
-    if m and "area" in lower:
-        b = float(m.group(1))
-        h = float(m.group(2))
-        ans = 0.5 * b * h
-
-        if help_mode == "hint":
-            reply = "Triangle area = 1/2 × base × height."
-        elif help_mode == "walkthrough":
-            reply = f"Area = 1/2 × {b:g} × {h:g} = {ans:g}."
-        else:
-            reply = f"The area is {ans:g}."
-
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
-
-    return None
-
-
-def solve_linear_equation(text: str, help_mode: str) -> Optional[SolverResult]:
-    if sp is None:
-        return None
-
-    lower = text.lower().replace("^", "**")
-
-    m = re.search(r"(?:solve for x|find x|value of x).*?([\-0-9a-z\+\*/\s\(\)]+=[\-0-9a-z\+\*/\s\(\)]+)", lower)
-    if not m:
-        m = re.search(r"([\-0-9a-z\+\*/\s\(\)]+=[\-0-9a-z\+\*/\s\(\)]+)", lower)
-        if not m:
-            return None
-
-    eq_text = m.group(1).strip()
-    eq_text = re.sub(r"(\d)([a-z])", r"\1*\2", eq_text)
-    eq_text = re.sub(r"([a-z])(\d)", r"\1*\2", eq_text)
-
-    parts = eq_text.split("=")
-    if len(parts) != 2:
-        return None
-
-    try:
-        x = sp.symbols("x")
-        left = sp.sympify(parts[0])
-        right = sp.sympify(parts[1])
-        sols = sp.solve(sp.Eq(left, right), x)
-        if not sols:
-            return None
-
-        sol = sols[0]
-
-        if help_mode == "hint":
-            reply = "Collect the x-terms on one side and constants on the other."
-        elif help_mode == "walkthrough":
-            reply = f"Solve {eq_text} for x.\nThis gives x = {sp.simplify(sol)}."
-        else:
-            reply = f"x = {sp.simplify(sol)}."
-
-        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=str(sp.simplify(sol)))
-    except Exception:
-        return None
-
-
-def compare_to_choices_numeric(answer_value: float, choices: Dict[str, str]) -> Optional[str]:
-    best_letter = None
-    best_diff = float("inf")
-
-    for letter, raw in choices.items():
-        expr = raw.strip()
-        expr_val = try_eval_expression(expr)
-
-        if expr_val is None:
-            nums = extract_numbers(expr)
-            if len(nums) == 1:
-                expr_val = nums[0]
-
-        if expr_val is None:
-            continue
-
-        diff = abs(expr_val - answer_value)
-        if diff < best_diff:
-            best_diff = diff
-            best_letter = letter
-
-    return best_letter
-
-
-def solve_by_option_checking(text: str, help_mode: str) -> Optional[SolverResult]:
-    choices = extract_choices(text)
-    if len(choices) < 3:
-        return None
-
-    expr = parse_direct_expression_question(text)
-    if expr:
-        val = try_eval_expression(expr)
-        if val is not None:
-            letter = compare_to_choices_numeric(val, choices)
-            if letter:
-                if help_mode == "hint":
-                    reply = "Evaluate the expression first, then match it to the answer choices."
-                elif help_mode == "walkthrough":
-                    reply = f"The expression evaluates to {val:g}, which matches choice {letter}."
-                else:
-                    reply = f"The correct choice is {letter}."
-
-                return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_letter=letter, answer_value=f"{val:g}")
-
-    lower = text.lower()
-    m = re.search(r"what is\s+(\d+(?:\.\d+)?)\s*%\s+of\s+(\d+(?:\.\d+)?)", lower)
-    if m:
-        val = float(m.group(1)) / 100 * float(m.group(2))
-        letter = compare_to_choices_numeric(val, choices)
-        if letter:
-            if help_mode == "hint":
-                reply = "Compute the percentage, then match it to the options."
-            elif help_mode == "walkthrough":
-                reply = f"{m.group(1)}% of {m.group(2)} = {val:g}, so the correct choice is {letter}."
-            else:
-                reply = f"The correct choice is {letter}."
-
-            return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_letter=letter, answer_value=f"{val:g}")
-
-    return None
-
-
-def solve_quant(text: str, help_mode: str) -> SolverResult:
-    solvers = [
-        solve_by_option_checking,
-        solve_basic_expression,
-        solve_percent_question,
-        solve_ratio_question,
-        solve_average_question,
-        solve_probability_question,
-        solve_geometry_question,
-        solve_linear_equation,
-    ]
-
-    for solver in solvers:
-        try:
-            out = solver(text, help_mode)
-            if out:
-                return out
-        except Exception:
-            pass
-
-    if help_mode == "hint":
-        reply = (
-            "Identify the question type first: arithmetic, percent, ratio, algebra, probability, "
-            "statistics, or geometry. Then extract the given numbers and set up the core relation."
-        )
-    elif help_mode == "walkthrough":
-        reply = (
-            "I can help with this, but I cannot confidently solve it from the current parse alone. "
-            "I can still talk through the first step or eliminate options if needed."
-        )
-    else:
-        reply = (
-            "I can help with this, but I can’t confidently solve it from the current parse alone yet."
-        )
-
-    return SolverResult(reply=reply, domain="quant", solved=False, help_mode=help_mode)
-
-
-# =========================================================
-# Conversational layer
-# =========================================================
-
-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: ParsedContext, help_mode: str) -> Optional[SolverResult]:
-    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:
-        hint_result = solve_quant(question_block, "hint")
-        return hint_result
-
-    if "answer" in lower or "which one" in lower or "are you sure" in lower:
-        answer_result = solve_quant(question_block, "answer")
-        return answer_result
-
-    return None
-
-
-# =========================================================
-# Main response logic
-# =========================================================
-
-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
-
-
-# =========================================================
-# Routes
-# =========================================================
-
 @app.get("/health")
 def health() -> Dict[str, Any]:
     return {"ok": True, "app": "GMAT Solver v3"}
@@ -1015,87 +32,7 @@ def health() -> Dict[str, Any]:
 
 @app.get("/", response_class=HTMLResponse)
 def home() -> str:
-    return """
-<!doctype html>
-<html>
-<head>
-  <meta charset="utf-8">
-  <title>GMAT Solver v3</title>
-  <style>
-    body { font-family: Arial, sans-serif; max-width: 900px; margin: 40px auto; padding: 0 16px; }
-    textarea { width: 100%; min-height: 220px; padding: 12px; font-size: 16px; }
-    .row { display: flex; gap: 16px; margin: 12px 0; flex-wrap: wrap; }
-    .card { border: 1px solid #ddd; border-radius: 10px; padding: 12px; flex: 1 1 220px; }
-    button { padding: 10px 16px; font-size: 16px; cursor: pointer; }
-    pre { white-space: pre-wrap; background: #f7f7f7; padding: 16px; border-radius: 10px; }
-    label { display: block; margin-bottom: 8px; font-weight: bold; }
-    select, input[type="range"] { width: 100%; }
-  </style>
-</head>
-<body>
-  <h1>GMAT Solver v3</h1>
-  <p>This version supports natural chat and hidden Unity context.</p>
-
-  <label for="message">Message</label>
-  <textarea id="message" placeholder="Try:
-why is it c
-
-Or paste a whole question."></textarea>
-
-  <div class="row">
-    <div class="card">
-      <label for="help_mode">Help mode</label>
-      <select id="help_mode">
-        <option value="answer" selected>answer</option>
-        <option value="hint">hint</option>
-        <option value="walkthrough">walkthrough</option>
-      </select>
-    </div>
-
-    <div class="card">
-      <label for="tone">Tone</label>
-      <input id="tone" type="range" min="0" max="1" step="0.01" value="0.5">
-    </div>
-
-    <div class="card">
-      <label for="verbosity">Verbosity</label>
-      <input id="verbosity" type="range" min="0" max="1" step="0.01" value="0.5">
-    </div>
-
-    <div class="card">
-      <label for="transparency">Transparency</label>
-      <input id="transparency" type="range" min="0" max="1" step="0.01" value="0.5">
-    </div>
-  </div>
-
-  <button onclick="send()">Send</button>
-
-  <h2>Response</h2>
-  <pre id="out">Waiting...</pre>
-
-  <script>
-    async function send() {
-      const payload = {
-        message: document.getElementById('message').value,
-        help_mode: document.getElementById('help_mode').value,
-        tone: parseFloat(document.getElementById('tone').value),
-        verbosity: parseFloat(document.getElementById('verbosity').value),
-        transparency: parseFloat(document.getElementById('transparency').value)
-      };
-
-      const res = await fetch('/chat', {
-        method: 'POST',
-        headers: {'Content-Type': 'application/json'},
-        body: JSON.stringify(payload)
-      });
-
-      const data = await res.json();
-      document.getElementById('out').textContent = JSON.stringify(data, null, 2);
-    }
-  </script>
-</body>
-</html>
-"""
+    return HOME_HTML
 
 
 @app.post("/chat")
@@ -1145,10 +82,6 @@ async def chat(request: Request) -> JSONResponse:
     )
 
 
-# =========================================================
-# Local dev entry
-# =========================================================
-
 if __name__ == "__main__":
     import uvicorn