verifiable-thinking-mcp 0.4.0

package/src/lib/compute/registry.ts

@@ -0,0 +1,145 @@
+/**
+ * Solver Registry - Registration of compute solvers
+ *
+ * Each solver declares its type mask and priority.
+ *
+ * To add a new solver:
+ * 1. Create a file in ./solvers/
+ * 2. Export `solver` (single) or `solvers` (array) with Solver interface
+ * 3. Import and register it below
+ */
+
+import { type SolverMask, SolverType, shouldTrySolver } from "./classifier.ts";
+// Import all solver modules
+import * as arithmeticModule from "./solvers/arithmetic.ts";
+import * as calculusModule from "./solvers/calculus.ts";
+import * as derivationModule from "./solvers/derivation.ts";
+import * as factsModule from "./solvers/facts.ts";
+import * as formulaModule from "./solvers/formula.ts";
+import * as logicModule from "./solvers/logic.ts";
+import * as probabilityModule from "./solvers/probability.ts";
+import * as statisticsModule from "./solvers/statistics.ts";
+import * as wordProblemsModule from "./solvers/word-problems.ts";
+import type { ComputeResult, Solver } from "./types.ts";
+
+// Re-export Solver type for convenience
+export type { Solver } from "./types.ts";
+
+// =============================================================================
+// REGISTRY
+// =============================================================================
+
+const solvers: Solver[] = [];
+let sortedCache: Solver[] | null = null;
+
+/**
+ * Register a solver. Call this at module load time.
+ */
+export function registerSolver(solver: Solver): void {
+  solvers.push(solver);
+  sortedCache = null; // Invalidate cache
+}
+
+/**
+ * Get all registered solvers, sorted by priority
+ */
+export function getSolvers(): Solver[] {
+  if (!sortedCache) {
+    sortedCache = [...solvers].sort((a, b) => a.priority - b.priority);
+  }
+  return sortedCache;
+}
+
+/**
+ * Get solvers that match a given mask, sorted by priority
+ */
+export function getSolversForMask(mask: SolverMask): Solver[] {
+  return getSolvers().filter((s) => shouldTrySolver(mask, s.types));
+}
+
+/**
+ * Run solvers matching the mask until one succeeds
+ */
+export function runSolvers(text: string, lower: string, mask: SolverMask): ComputeResult {
+  const matchingSolvers = getSolversForMask(mask);
+
+  for (const solver of matchingSolvers) {
+    const result = solver.solve(text, lower);
+    if (result.solved) {
+      return result;
+    }
+  }
+
+  return { solved: false, confidence: 0 };
+}
+
+/**
+ * Get registry stats for debugging
+ */
+export function getRegistryStats(): { count: number; byType: Record<string, number> } {
+  const byType: Record<string, number> = {};
+
+  for (const solver of solvers) {
+    if (solver.types & SolverType.ARITHMETIC) byType.arithmetic = (byType.arithmetic || 0) + 1;
+    if (solver.types & SolverType.FORMULA_TIER1)
+      byType.formula_tier1 = (byType.formula_tier1 || 0) + 1;
+    if (solver.types & SolverType.FORMULA_TIER2)
+      byType.formula_tier2 = (byType.formula_tier2 || 0) + 1;
+    if (solver.types & SolverType.FORMULA_TIER3)
+      byType.formula_tier3 = (byType.formula_tier3 || 0) + 1;
+    if (solver.types & SolverType.FORMULA_TIER4)
+      byType.formula_tier4 = (byType.formula_tier4 || 0) + 1;
+    if (solver.types & SolverType.WORD_PROBLEM)
+      byType.word_problem = (byType.word_problem || 0) + 1;
+    if (solver.types & SolverType.MULTI_STEP) byType.multi_step = (byType.multi_step || 0) + 1;
+    if (solver.types & SolverType.CALCULUS) byType.calculus = (byType.calculus || 0) + 1;
+    if (solver.types & SolverType.FACTS) byType.facts = (byType.facts || 0) + 1;
+    if (solver.types & SolverType.LOGIC) byType.logic = (byType.logic || 0) + 1;
+    if (solver.types & SolverType.PROBABILITY) byType.probability = (byType.probability || 0) + 1;
+    if (solver.types & SolverType.DERIVATION) byType.derivation = (byType.derivation || 0) + 1;
+  }
+
+  return { count: solvers.length, byType };
+}
+
+/**
+ * List all registered solvers with their descriptions (for debugging/docs)
+ */
+export function listSolvers(): Array<{ name: string; description: string; priority: number }> {
+  return getSolvers().map((s) => ({
+    name: s.name,
+    description: s.description ?? "(no description)",
+    priority: s.priority,
+  }));
+}
+
+// =============================================================================
+// EXPLICIT SOLVER REGISTRATION
+// Register all solvers from modules (no Bun.Glob needed - works with Node.js too)
+// =============================================================================
+
+// Helper to register solvers from a module
+function registerFromModule(mod: Record<string, unknown>): void {
+  // Register single solver
+  if (mod.solver && typeof mod.solver === "object") {
+    registerSolver(mod.solver as Solver);
+  }
+
+  // Register multiple solvers
+  if (mod.solvers && Array.isArray(mod.solvers)) {
+    for (const s of mod.solvers) {
+      registerSolver(s as Solver);
+    }
+  }
+}
+
+// Register all solver modules
+registerFromModule(arithmeticModule);
+registerFromModule(calculusModule);
+registerFromModule(derivationModule);
+registerFromModule(factsModule);
+registerFromModule(formulaModule);
+registerFromModule(logicModule);
+registerFromModule(probabilityModule);
+registerFromModule(statisticsModule);
+registerFromModule(wordProblemsModule);

package/src/lib/compute/solvers/arithmetic.ts

@@ -0,0 +1,65 @@
+/**
+ * Arithmetic solver - safe evaluation of math expressions
+ * Uses recursive descent parser instead of eval/Function
+ */
+
+import { SolverType } from "../classifier.ts";
+import { safeEvaluate } from "../math.ts";
+import { ARITHMETIC } from "../patterns.ts";
+import type { ComputeResult, Solver } from "../types.ts";
+
+/**
+ * Safe arithmetic evaluation using recursive descent parser
+ * Supports: +, -, *, /, ^, (), negative numbers, decimals
+ */
+export function tryArithmetic(text: string): ComputeResult {
+  const start = performance.now();
+
+  const patterns = [
+    ARITHMETIC.whatIs,
+    ARITHMETIC.calculate,
+    ARITHMETIC.compute,
+    ARITHMETIC.evaluate,
+    ARITHMETIC.equalsQuestion,
+    ARITHMETIC.bareExpression,
+  ];
+
+  let expr: string | null = null;
+  for (const pattern of patterns) {
+    const match = text.match(pattern);
+    if (match?.[1]) {
+      expr = match[1].trim();
+      break;
+    }
+  }
+
+  if (!expr) return { solved: false, confidence: 0 };
+
+  // Use safe recursive descent parser instead of new Function()
+  const result = safeEvaluate(expr);
+
+  if (result.success && result.value !== undefined) {
+    const time_ms = performance.now() - start;
+    return {
+      solved: true,
+      result: Number.isInteger(result.value) ? result.value : +result.value.toFixed(10),
+      method: "arithmetic",
+      confidence: 1.0,
+      time_ms,
+    };
+  }
+
+  return { solved: false, confidence: 0 };
+}
+
+// =============================================================================
+// SOLVER REGISTRATION
+// =============================================================================
+
+export const solver: Solver = {
+  name: "arithmetic",
+  description: "Safe evaluation of math expressions (+, -, *, /, ^, parentheses)",
+  types: SolverType.ARITHMETIC,
+  priority: 10,
+  solve: (text, _lower) => tryArithmetic(text),
+};

package/src/lib/compute/solvers/calculus.ts

@@ -0,0 +1,249 @@
+/**
+ * Calculus solver - derivatives and definite integrals of polynomials
+ */
+
+import { SolverType } from "../classifier.ts";
+import { formatResult, normalizeUnicodeSuperscripts } from "../math.ts";
+import { CALCULUS } from "../patterns.ts";
+import type { ComputeResult, PolyTerm, Solver } from "../types.ts";
+
+/** Parse a polynomial string like "3x^2 + 2x - 5" into terms @internal */
+function parsePolynomial(text: string): PolyTerm[] {
+  // Normalize: whitespace, case, and Unicode superscripts
+  const clean = normalizeUnicodeSuperscripts(text).replace(/\s+/g, "").toLowerCase();
+
+  const terms: PolyTerm[] = [];
+
+  // Match terms like: "3x^2", "-x", "5", "+2x^-1"
+  const termRegex = /([+-]?)(\d*\.?\d*)x(?:\^([+-]?\d+))?|([+-]?)(\d+\.?\d*)/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = termRegex.exec(clean)) !== null) {
+    if (match[0] === "") continue;
+
+    // Variable term (ax^n)
+    if (match[2] !== undefined && match[0].includes("x")) {
+      const sign = match[1] === "-" ? -1 : 1;
+      const coeffStr = match[2];
+      const coeff =
+        sign * (coeffStr === "" || coeffStr === "+" || coeffStr === "-" ? 1 : parseFloat(coeffStr));
+      const exp = match[3] ? parseInt(match[3], 10) : 1;
+      terms.push({ coeff, exp });
+    }
+    // Constant term
+    else if (match[5] !== undefined) {
+      const sign = match[4] === "-" ? -1 : 1;
+      const coeff = sign * parseFloat(match[5]);
+      terms.push({ coeff, exp: 0 });
+    }
+  }
+  return terms;
+}
+
+/** Differentiate polynomial terms using power rule @internal */
+function differentiateTerms(terms: PolyTerm[]): PolyTerm[] {
+  return terms
+    .map((t) => ({ coeff: t.coeff * t.exp, exp: t.exp - 1 }))
+    .filter((t) => t.coeff !== 0);
+}
+
+/** Integrate polynomial terms using power rule @internal */
+function integrateTerms(terms: PolyTerm[]): PolyTerm[] {
+  return terms.map((t) => {
+    if (t.exp === -1) throw new Error("Cannot integrate 1/x in polynomial mode");
+    return { coeff: t.coeff / (t.exp + 1), exp: t.exp + 1 };
+  });
+}
+
+/**
+ * Simpson's Rule for numerical integration
+ * Works for any continuous function, not just polynomials
+ * Accuracy: O(h^4) where h = (b-a)/n
+ */
+export function simpsonIntegrate(fn: (x: number) => number, a: number, b: number, n = 100): number {
+  // Handle edge cases
+  if (!Number.isFinite(a) || !Number.isFinite(b)) return NaN;
+  if (a === b) return 0;
+
+  // n must be even for Simpson's rule, and capped for safety
+  if (n % 2 !== 0) n++;
+  n = Math.min(n, 10000);
+
+  const h = (b - a) / n;
+  let sum = fn(a) + fn(b);
+
+  for (let i = 1; i < n; i++) {
+    const x = a + i * h;
+    // Odd indices get weight 4, even indices get weight 2
+    sum += (i % 2 === 0 ? 2 : 4) * fn(x);
+  }
+
+  return (h / 3) * sum;
+}
+
+/**
+ * Create a safe evaluator function for simple math expressions
+ * Supports: x, numbers, +, -, *, /, ^, sin, cos, tan, exp, ln, sqrt
+ * Returns null if expression is not safe to evaluate
+ * @internal
+ */
+function createSafeFunction(expr: string): ((x: number) => number) | null {
+  // Normalize
+  const clean = expr.toLowerCase().replace(/\s+/g, "").replace(/\*\*/g, "^");
+
+  // Whitelist: only allow safe math characters and functions
+  const safePattern = /^[x\d+\-*/^().,sincotaexplnqr]+$/;
+  if (!safePattern.test(clean)) return null;
+
+  // Build function by replacing math operations with safe JS equivalents
+  // This is still not using eval - we construct the function from parsed components
+  try {
+    // For now, only support polynomial-like expressions that our parser handles
+    // More complex expressions (sin, cos, etc.) would need the full parser
+    const terms = parsePolynomial(clean);
+    if (terms.length === 0) return null;
+
+    return (x: number) => evaluatePolynomial(terms, x);
+  } catch {
+    return null;
+  }
+}
+
+/** Evaluate polynomial at a point @internal */
+function evaluatePolynomial(terms: PolyTerm[], x: number): number {
+  return terms.reduce((sum, t) => sum + t.coeff * x ** t.exp, 0);
+}
+
+/**
+ * Try to solve calculus problems (derivatives and integrals)
+ */
+export function tryCalculus(text: string): ComputeResult {
+  const start = performance.now();
+
+  // Normalize Unicode superscripts early so regex patterns work
+  const normalizedText = normalizeUnicodeSuperscripts(text);
+
+  // =========================================================================
+  // DERIVATIVES: d/dx of f(x) at x=a
+  // =========================================================================
+  for (const pattern of CALCULUS.derivative) {
+    const match = normalizedText.match(pattern);
+    if (match?.[1]) {
+      try {
+        // Extract just the expression part
+        let expr = match[1].trim();
+        // Remove trailing punctuation, extra phrases, and redundant "d/dx of"
+        expr = expr
+          .replace(/[.?!]+$/, "")
+          .replace(/\s*(at|evaluated|when).*$/i, "")
+          .replace(/^d\/dx\s*(of\s*)?/i, "")
+          .replace(/^of\s+/i, "")
+          .trim();
+
+        const terms = parsePolynomial(expr);
+        if (terms.length === 0) continue;
+
+        const diffTerms = differentiateTerms(terms);
+
+        // If evaluating at a point (group 2 present)
+        if (match[2]) {
+          const xVal = parseFloat(match[2]);
+          const result = evaluatePolynomial(diffTerms, xVal);
+          const time_ms = performance.now() - start;
+          return {
+            solved: true,
+            result: formatResult(result),
+            method: "derivative_eval",
+            confidence: 1.0,
+            time_ms,
+          };
+        }
+
+        // Return symbolic derivative (format as string)
+        const resultStr = diffTerms
+          .map((t, i) => {
+            const sign = t.coeff >= 0 ? (i > 0 ? " + " : "") : " - ";
+            const absCoeff = Math.abs(t.coeff);
+            const cStr = absCoeff === 1 && t.exp !== 0 ? "" : String(absCoeff);
+            const xStr = t.exp === 0 ? "" : t.exp === 1 ? "x" : `x^${t.exp}`;
+            return `${sign}${cStr}${xStr}`;
+          })
+          .join("")
+          .trim();
+
+        const time_ms = performance.now() - start;
+        return {
+          solved: true,
+          result: resultStr || "0",
+          method: "derivative_symbolic",
+          confidence: 1.0,
+          time_ms,
+        };
+      } catch {
+        // Parsing failed, continue
+      }
+    }
+  }
+
+  // =========================================================================
+  // DEFINITE INTEGRALS: integral of f(x) from a to b
+  // =========================================================================
+  for (const pattern of CALCULUS.integral) {
+    const match = text.match(pattern);
+    if (match?.[1] && match[2] && match[3]) {
+      const a = parseFloat(match[2]);
+      const b = parseFloat(match[3]);
+
+      // First try exact polynomial integration
+      try {
+        const terms = parsePolynomial(match[1]);
+        if (terms.length > 0) {
+          const integrated = integrateTerms(terms);
+          const result = evaluatePolynomial(integrated, b) - evaluatePolynomial(integrated, a);
+          const time_ms = performance.now() - start;
+          return {
+            solved: true,
+            result: formatResult(result),
+            method: "definite_integral",
+            confidence: 1.0,
+            time_ms,
+          };
+        }
+      } catch {
+        // Polynomial parsing/integration failed, try numerical
+      }
+
+      // Fallback: Simpson's rule for numerical integration
+      const fn = createSafeFunction(match[1]);
+      if (fn) {
+        try {
+          const result = simpsonIntegrate(fn, a, b, 1000);
+          const time_ms = performance.now() - start;
+          return {
+            solved: true,
+            result: formatResult(result),
+            method: "numerical_integral",
+            confidence: 0.95, // Slightly lower confidence for numerical
+            time_ms,
+          };
+        } catch {
+          // Numerical integration failed
+        }
+      }
+    }
+  }
+
+  return { solved: false, confidence: 0 };
+}
+
+// =============================================================================
+// SOLVER REGISTRATION
+// =============================================================================
+
+export const solver: Solver = {
+  name: "calculus",
+  description: "Derivatives and definite integrals of polynomials, with Simpson's rule fallback",
+  types: SolverType.CALCULUS,
+  priority: 50,
+  solve: (text, _lower) => tryCalculus(text),
+};