browser-assistant 2.8.5 → 2.8.6

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
     "manifest_version": 3,
     "name": "Browser Assistant",
-    "version": "2.8.5",
+  "version": "2.8.6",
     "description": "Scans webpages for MCQs and coding problems. Powered by Groq (cloud) and Ollama (local fallback).",
     "permissions": [
         "activeTab",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-assistant",
-  "version": "2.8.5",
+  "version": "2.8.6",
   "description": "Chrome extension and local Python backend for exploring webpage questions and coding exercises",
   "license": "MIT",
   "repository": {

package/server/main.py

@@ -24,7 +24,8 @@ from fastapi.exception_handlers import http_exception_handler
 from local_security import install_local_guards, redact, sanitize_data
 from vision_images import (compress_image_base64, unique_image_blocks, collect_image_evidence,
                            cross_check_visual_answers, relative_percentage_question, RELATIVE_PERCENTAGE_INSTRUCTION,
-                           answer_permutation, cross_check_text_answers, VisionRateLimitError, VisionUnconfirmedError)
+                           answer_permutation, cross_check_text_answers, solve_matrix_choice,
+                           VisionRateLimitError, VisionUnconfirmedError)
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
 logger = logging.getLogger("browser-assistant")
@@ -190,7 +191,7 @@ async def lifespan(_app: FastAPI):
             client.close()
 
 
-app = FastAPI(title="Browser Assistant API", version="2.8.5", lifespan=lifespan)
+app = FastAPI(title="Browser Assistant API", version="2.8.6", lifespan=lifespan)
 install_local_guards(app)
 
 @app.exception_handler(HTTPException)
@@ -1190,6 +1191,13 @@ async def review_and_correct_code(
 
 # ── Routes ────────────────────────────────────────────────────────────────────
 
+def calculated_matrix_result(text, language):
+    item = solve_matrix_choice(text)
+    if item is not None:
+        return {"results": json.dumps([item], ensure_ascii=False), "provider": "local matrix calculation [verified]",
+                "language": language, "answer_verified": True, "code_reviewed": False}
+
+
 @app.post("/solve")
 async def solve_questions(content: PageContent):
     # Trim oversized page text to stay within token limits
@@ -1232,6 +1240,10 @@ REPAIR MODE:
     )
     strict_code_review = require_code and (content.review_before_submit or not FAST_CODE_MODE or STRICT_REPAIR_REVIEW)
     verify_answers = not require_code and (content.verify_answer or not FAST_SCAN_MODE)
+    if not require_code and content.practice_type in {'auto', 'mcq', 'math', 'aptitude'}:
+        matrix_result = calculated_matrix_result(trimmed_text, language)
+        if matrix_result is not None:
+            return matrix_result
 
     async def confirm_answers(cleaned, source_model=None):
         if not verify_answers or not any(item['type'] == 'mcq' for item in json.loads(cleaned)):
@@ -1395,6 +1407,11 @@ async def _solve_vision(content: VisionContent):
             compressed.append(await asyncio.to_thread(compress_image_base64, image, max_dim=2400, quality=95))
         except ValueError as exc:
             raise HTTPException(422, f'Image {index}: {exc}') from exc
+    is_code_scan = content.practice_type == "code" or (content.practice_type == "auto" and bool(content.language))
+    if not is_code_scan and content.practice_type in {'auto', 'mcq', 'math', 'aptitude'}:
+        matrix_result = calculated_matrix_result(content.text, content.language or CODE_DEFAULT_LANGUAGE)
+        if matrix_result is not None:
+            return matrix_result
     image_blocks, image_positions = unique_image_blocks(compressed)
 
     clients = tuple(_groq_clients)
@@ -1406,7 +1423,6 @@ async def _solve_vision(content: VisionContent):
     loop = asyncio.get_running_loop()
     errors = []
     rate_limit_resets = []
-    is_code_scan = content.practice_type == "code" or (content.practice_type == "auto" and bool(content.language))
     comparison = None if is_code_scan else relative_percentage_question(content.text)
     unconfirmed = False
     vision_token_limit = 4096 if is_code_scan else VISION_MAX_TOKENS

package/server/vision_images.py

@@ -170,9 +170,13 @@ def answer_permutation(value):
 MATRIX_SYNTAX = re.compile(r'\\begin\{(?:[bpBvV]?matrix|smallmatrix)\}')
 
 
-def numeric_matrix_key(value):
+def unwrap_math(value):
     text = re.sub(r'^\${1,2}|\${1,2}$', '', value.strip())
-    text = re.sub(r'^\\[\[(]|\\[\])]$', '', text).strip().replace('−', '-')
+    return re.sub(r'^\\[\[(]|\\[\])]$', '', text).strip().replace('−', '-')
+
+
+def matrix_cells(value):
+    text = unwrap_math(value)
     latex = re.fullmatch(r'\\begin\{([bpBvV]?matrix|smallmatrix)\}(.*?)\\end\{\1\}', text, re.S)
     array = re.fullmatch(r'\[\s*(\[[^\[\]]+\](?:\s*,\s*\[[^\[\]]+\])*)\s*\]', text)
     if latex:
@@ -181,13 +185,97 @@ def numeric_matrix_key(value):
         rows = [row.split(',') for row in re.findall(r'\[([^\[\]]+)\]', array[1])]
     else:
         return None
-    cells = [[cell.strip() for cell in row] for row in rows]
+    return [[cell.strip() for cell in row] for row in rows]
+
+
+def numeric_matrix_key(value):
+    cells = matrix_cells(value)
     if cells and all(len(row) == len(cells[0]) and all(
             re.fullmatch(r'[+-]?(?:\d+(?:\.\d+)?|\.\d+)', cell, re.ASCII) for cell in row) for row in cells):
         return json.dumps(cells, separators=(',', ':'))
     return None
 
 
+def matrix_2x2(value):
+    rows = matrix_cells(value)
+    if not rows or len(rows) != 2 or any(len(row) != 2 for row in rows):
+        return None
+    entries = []
+    for cell in (cell for row in rows for cell in row):
+        cell = re.sub(r'^([+-]?)\\(?:[dt]?frac)\{([+-]?\d{1,15})\}\{(\d{1,15})\}$',
+                      r'\1\2/\3', cell)
+        if not re.fullmatch(rf'(?:{DECIMAL_VALUE}|[+-]?\d{{1,15}}/\d{{1,15}})', cell):
+            return None
+        try:
+            entries.append(Fraction(cell))
+        except ZeroDivisionError:
+            return None
+    return tuple(entries)
+
+
+def solve_matrix_choice(text):
+    """Calculate a self-contained matrix question with one matching displayed choice."""
+    question, separator, option_text = text.strip().rpartition('\nA.')
+    if not separator:
+        return None
+    question = re.sub(r'\n(?:Question format: )?Select one answer\.$', '', question, flags=re.I)
+    question = re.sub(r'^\d+\s*of\s*\d+\s*questions?\s*\d+\s*marks?\s*', '', question, flags=re.I)
+    # Math delimiters and layout whitespace do not carry meaning in these prompts.
+    prompt = re.sub(r'\s+', ' ', question.replace('$', '')).strip()
+    inverse = re.fullmatch(
+        r'For ([A-Z])\s*=\s*(.+?),\s*what is \1\^(?:\{-1\}|-1)'
+        r'(?: computed using the adjugate method)?\?', prompt,
+    )
+    product = re.fullmatch(
+        r'For matrices ([A-Z]) with shape \(\s*([a-z])\s*,\s*([a-z])\s*\) and '
+        r'([A-Z]) with shape \(\s*([a-z])\s*,\s*([a-z])\s*\),\s*'
+        r'which condition must hold for the product (\1\4|\4\1) to be defined\?', prompt,
+    )
+    if inverse:
+        entries = matrix_2x2(inverse[2])
+        if entries is None:
+            return None
+        a, b, c, d = entries
+        determinant = a * d - b * c
+        if not determinant:
+            return None
+        expected = (d / determinant, -b / determinant, -c / determinant, a / determinant)
+        parse_option = matrix_2x2
+        reasoning = f'The determinant is ({a})({d}) − ({b})({c}) = {determinant}. Divide the adjugate by the determinant.'
+    elif product:
+        first, first_rows, first_cols, second, second_rows, second_cols, order = product.groups()
+        if first == second or len({first_rows, first_cols, second_rows, second_cols}) != 4:
+            return None
+        left_cols, right_rows = (first_cols, second_rows) if order == first + second else (second_cols, first_rows)
+        expected = frozenset((left_cols, right_rows))
+
+        def parse_option(value):
+            equation = re.fullmatch(r'([a-z])\s*=\s*([a-z])', unwrap_math(value))
+            return frozenset(equation.groups()) if equation else None
+
+        reasoning = f'The left matrix has {left_cols} columns and the right matrix has {right_rows} rows. These must be equal.'
+    else:
+        return None
+
+    lines = ('A.' + option_text).splitlines()
+    if not 2 <= len(lines) <= 26:
+        return None
+    matches = []
+    for index, line in enumerate(lines):
+        letter = chr(ord('A') + index)
+        option = re.fullmatch(rf'{letter}\.\s*(\S.*)', line)
+        if not option:
+            return None
+        value = parse_option(option[1])
+        if value is None:
+            return None
+        if value == expected:
+            matches.append(f'Option {letter}: {option[1]}')
+    if len(matches) != 1:
+        return None
+    return {'type': 'mcq', 'question': question, 'answer': matches[0], 'reasoning': reasoning}
+
+
 def normalize_checked_answer(value, *, matrix_math=False):
     if answer_permutation(value):
         return json.dumps(value)