@stackmemoryai/stackmemory 1.0.0 → 1.2.0

package/dist/src/integrations/mcp/server.js

@@ -30,6 +30,7 @@ import { TraceDetector } from "../../core/trace/trace-detector.js";
 import { LLMContextRetrieval } from "../../core/retrieval/index.js";
 import { DiscoveryHandlers } from "./handlers/discovery-handlers.js";
 import { DiffMemHandlers } from "./handlers/diffmem-handlers.js";
+import { fuzzyEdit } from "../../utils/fuzzy-edit.js";
 import { v4 as uuidv4 } from "uuid";
 import {
   DEFAULT_PLANNER_MODEL,
@@ -62,6 +63,7 @@ class LocalStackMemoryMCP {
   contextRetrieval;
   discoveryHandlers;
   diffMemHandlers;
+  providerHandlers = null;
   pendingPlans = /* @__PURE__ */ new Map();
   constructor() {
     this.projectRoot = this.findProjectRoot();
@@ -91,6 +93,18 @@ class LocalStackMemoryMCP {
         influence_score REAL,
         timestamp INTEGER DEFAULT (unixepoch())
       );
+
+      CREATE TABLE IF NOT EXISTS edit_telemetry (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp INTEGER NOT NULL DEFAULT (unixepoch()),
+        session_id TEXT,
+        tool_name TEXT NOT NULL,
+        file_path TEXT,
+        success INTEGER NOT NULL DEFAULT 1,
+        error_type TEXT,
+        error_message TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_edit_telemetry_ts ON edit_telemetry(timestamp);
     `);
     this.frameManager = new FrameManager(this.db, this.projectId);
     this.initLinearIfEnabled();
@@ -122,6 +136,7 @@ class LocalStackMemoryMCP {
       projectRoot: this.projectRoot
     });
     this.diffMemHandlers = new DiffMemHandlers();
+    this.initProviderHandlers();
     this.setupHandlers();
     this.loadInitialContext();
     this.loadPendingPlans();
@@ -243,6 +258,16 @@ ${summary}...`, 0.8);
       this.contexts.set(ctx.id, ctx);
     });
   }
+  async initProviderHandlers() {
+    if (!isFeatureEnabled("multiProvider")) return;
+    try {
+      const { ProviderHandlers } = await import("./handlers/provider-handlers.js");
+      this.providerHandlers = new ProviderHandlers();
+      logger.info("Provider handlers initialized (multiProvider enabled)");
+    } catch (error) {
+      logger.warn("Failed to initialize provider handlers", { error });
+    }
+  }
   setupHandlers() {
     this.server.setRequestHandler(
       z.object({
@@ -1047,7 +1072,108 @@ ${summary}...`, 0.8);
                 type: "object",
                 properties: {}
               }
-            }
+            },
+            // Provider tools (only active when STACKMEMORY_MULTI_PROVIDER=true)
+            ...isFeatureEnabled("multiProvider") ? [
+              {
+                name: "delegate_to_model",
+                description: "Route a prompt to a specific provider/model. Uses smart cost-based routing by default.",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    prompt: {
+                      type: "string",
+                      description: "The prompt to send"
+                    },
+                    provider: {
+                      type: "string",
+                      enum: [
+                        "anthropic",
+                        "cerebras",
+                        "deepinfra",
+                        "openai",
+                        "openrouter"
+                      ],
+                      description: "Override provider (auto-routes if omitted)"
+                    },
+                    model: {
+                      type: "string",
+                      description: "Override model name"
+                    },
+                    taskType: {
+                      type: "string",
+                      enum: [
+                        "linting",
+                        "context",
+                        "code",
+                        "testing",
+                        "review",
+                        "plan"
+                      ],
+                      description: "Task type for auto-routing"
+                    },
+                    maxTokens: {
+                      type: "number",
+                      description: "Max tokens"
+                    },
+                    temperature: { type: "number" },
+                    system: {
+                      type: "string",
+                      description: "System prompt"
+                    }
+                  },
+                  required: ["prompt"]
+                }
+              },
+              {
+                name: "batch_submit",
+                description: "Submit prompts to Anthropic Batch API (50% discount, async)",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    prompts: {
+                      type: "array",
+                      items: {
+                        type: "object",
+                        properties: {
+                          id: { type: "string" },
+                          prompt: { type: "string" },
+                          model: { type: "string" },
+                          maxTokens: { type: "number" },
+                          system: { type: "string" }
+                        },
+                        required: ["id", "prompt"]
+                      },
+                      description: "Array of prompts to batch"
+                    },
+                    description: {
+                      type: "string",
+                      description: "Batch job description"
+                    }
+                  },
+                  required: ["prompts"]
+                }
+              },
+              {
+                name: "batch_check",
+                description: "Check status or retrieve results for a batch job",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    batchId: {
+                      type: "string",
+                      description: "Batch job ID"
+                    },
+                    retrieve: {
+                      type: "boolean",
+                      description: "Retrieve results if complete",
+                      default: false
+                    }
+                  },
+                  required: ["batchId"]
+                }
+              }
+            ] : []
           ]
         };
       }
@@ -1195,6 +1321,58 @@ ${summary}...`, 0.8);
             case "diffmem_status":
               result = await this.diffMemHandlers.handleStatus();
               break;
+            case "sm_edit":
+              result = await this.handleSmEdit(args);
+              break;
+            // Provider tools
+            case "delegate_to_model":
+              if (!this.providerHandlers) {
+                result = {
+                  content: [
+                    {
+                      type: "text",
+                      text: "Multi-provider routing is disabled."
+                    }
+                  ]
+                };
+              } else {
+                result = await this.providerHandlers.handleDelegateToModel(
+                  args
+                );
+              }
+              break;
+            case "batch_submit":
+              if (!this.providerHandlers) {
+                result = {
+                  content: [
+                    {
+                      type: "text",
+                      text: "Multi-provider routing is disabled."
+                    }
+                  ]
+                };
+              } else {
+                result = await this.providerHandlers.handleBatchSubmit(
+                  args
+                );
+              }
+              break;
+            case "batch_check":
+              if (!this.providerHandlers) {
+                result = {
+                  content: [
+                    {
+                      type: "text",
+                      text: "Multi-provider routing is disabled."
+                    }
+                  ]
+                };
+              } else {
+                result = await this.providerHandlers.handleBatchCheck(
+                  args
+                );
+              }
+              break;
             default:
               throw new Error(`Unknown tool: ${name}`);
           }
@@ -2639,6 +2817,34 @@ ${typeBreakdown}`
       };
     }
   }
+  async handleSmEdit(args) {
+    const {
+      file_path: filePath,
+      old_string: oldString,
+      new_string: newString,
+      threshold = 0.85
+    } = args;
+    if (!filePath || !oldString || newString === void 0) {
+      throw new Error("file_path, old_string, and new_string are required");
+    }
+    const { readFileSync: readFileSync2, writeFileSync: writeFileSync2 } = await import("fs");
+    const content = readFileSync2(filePath, "utf-8");
+    const editResult = fuzzyEdit(content, oldString, newString, threshold);
+    if (!editResult) {
+      return {
+        success: false,
+        error: "No match found above threshold",
+        threshold
+      };
+    }
+    writeFileSync2(filePath, editResult.content, "utf-8");
+    return {
+      success: true,
+      method: editResult.match.method,
+      confidence: editResult.match.confidence,
+      matchedText: editResult.match.matchedText.length > 200 ? editResult.match.matchedText.slice(0, 200) + "..." : editResult.match.matchedText
+    };
+  }
   async start() {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);

package/dist/src/integrations/mcp/tool-definitions.js

@@ -12,7 +12,8 @@ class MCPToolDefinitions {
       ...this.getTaskTools(),
       ...this.getLinearTools(),
       ...this.getTraceTools(),
-      ...this.getDiscoveryTools()
+      ...this.getDiscoveryTools(),
+      ...this.getEditTools()
     ];
   }
   /**
@@ -670,6 +671,40 @@ class MCPToolDefinitions {
       }
     ];
   }
+  /**
+   * Edit tools (fuzzy edit fallback)
+   */
+  getEditTools() {
+    return [
+      {
+        name: "sm_edit",
+        description: "Fuzzy file edit \u2014 fallback when Claude Code's Edit tool fails on whitespace or indentation mismatches. Uses four-tier matching: exact, whitespace-normalized, indentation-insensitive, and line-level fuzzy (Levenshtein).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            file_path: {
+              type: "string",
+              description: "Absolute path to the file to edit"
+            },
+            old_string: {
+              type: "string",
+              description: "The text to find and replace"
+            },
+            new_string: {
+              type: "string",
+              description: "The replacement text"
+            },
+            threshold: {
+              type: "number",
+              default: 0.85,
+              description: "Minimum similarity threshold for fuzzy matching (0-1). Default 0.85."
+            }
+          },
+          required: ["file_path", "old_string", "new_string"]
+        }
+      }
+    ];
+  }
   /**
    * Get tool definition by name
    */
@@ -691,6 +726,8 @@ class MCPToolDefinitions {
         return this.getTraceTools();
       case "discovery":
         return this.getDiscoveryTools();
+      case "edit":
+        return this.getEditTools();
       default:
         return [];
     }

package/dist/src/orchestrators/multimodal/baselines.js

@@ -0,0 +1,128 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const SWE_BENCH_BASELINES = [
+  {
+    agent: "Claude Code",
+    model: "claude-sonnet-4",
+    benchmark: "swe-bench-verified",
+    resolveRate: 0.704,
+    date: "2025-12-01",
+    source: "https://www.swebench.com/"
+  },
+  {
+    agent: "Devin",
+    model: "mixed",
+    benchmark: "swe-bench-verified",
+    resolveRate: 0.551,
+    date: "2025-10-01",
+    source: "https://www.swebench.com/"
+  },
+  {
+    agent: "OpenHands",
+    model: "claude-sonnet-4",
+    benchmark: "swe-bench-verified",
+    resolveRate: 0.535,
+    date: "2025-09-01",
+    source: "https://www.swebench.com/"
+  },
+  {
+    agent: "Aider",
+    model: "claude-sonnet-4",
+    benchmark: "swe-bench-verified",
+    resolveRate: 0.489,
+    date: "2025-10-01",
+    source: "https://www.swebench.com/"
+  }
+];
+const HARNESS_TARGETS = {
+  /** Plan generation should complete within 10s */
+  planLatencyP95Ms: 1e4,
+  /**
+   * Full cycle (plan + implement + critique) within 5 minutes.
+   * Codex execution benchmarks show 89-231s for real runs (1-2 iterations).
+   * 300s allows for 2-iteration runs with margin.
+   */
+  totalLatencyP95Ms: 3e5,
+  /**
+   * Single-iteration (first-pass) latency ceiling: 2.5 minutes.
+   * Based on observed single-pass runs of 89-115s with headroom.
+   */
+  singleIterLatencyP95Ms: 15e4,
+  /** First-pass approval rate (no retries needed) */
+  firstPassApprovalRate: 0.7,
+  /** Edit success rate (exact + fuzzy combined) */
+  editSuccessRate: 0.9,
+  /** Edit fuzzy fallback rate (lower = better, means exact match works) */
+  editFuzzyFallbackRate: 0.15,
+  /** Context overhead should be < 6000 tokens */
+  contextTokenBudget: 6e3
+};
+function summarizeRuns(runs) {
+  if (runs.length === 0) {
+    return {
+      totalRuns: 0,
+      approvalRate: 0,
+      firstPassRate: 0,
+      avgIterations: 0,
+      avgPlanLatencyMs: 0,
+      avgTotalLatencyMs: 0,
+      p95PlanLatencyMs: 0,
+      p95TotalLatencyMs: 0,
+      p95SingleIterLatencyMs: 0,
+      editSuccessRate: 0,
+      editFuzzyRate: 0,
+      avgContextTokens: 0,
+      passesTargets: {}
+    };
+  }
+  const approvedRuns = runs.filter((r) => r.approved);
+  const firstPassRuns = runs.filter((r) => r.approved && r.iterations <= 1);
+  const totalEdits = runs.reduce((s, r) => s + r.editAttempts, 0);
+  const totalEditSuccesses = runs.reduce((s, r) => s + r.editSuccesses, 0);
+  const totalFuzzy = runs.reduce((s, r) => s + r.editFuzzyFallbacks, 0);
+  const planLatencies = runs.map((r) => r.planLatencyMs).sort((a, b) => a - b);
+  const totalLatencies = runs.map((r) => r.totalLatencyMs).sort((a, b) => a - b);
+  const p95Idx = Math.min(Math.ceil(runs.length * 0.95) - 1, runs.length - 1);
+  const approvalRate = approvedRuns.length / runs.length;
+  const firstPassRate = firstPassRuns.length / runs.length;
+  const editSuccessRate = totalEdits > 0 ? totalEditSuccesses / totalEdits : 1;
+  const editFuzzyRate = totalEditSuccesses > 0 ? totalFuzzy / totalEditSuccesses : 0;
+  const avgContextTokens = runs.reduce((s, r) => s + r.contextTokens, 0) / runs.length;
+  const p95Plan = planLatencies[p95Idx];
+  const p95Total = totalLatencies[p95Idx];
+  const singleIterLatencies = runs.filter((r) => r.approved && r.iterations <= 1).map((r) => r.totalLatencyMs).sort((a, b) => a - b);
+  const p95SingleIter = singleIterLatencies.length > 0 ? singleIterLatencies[Math.min(
+    Math.ceil(singleIterLatencies.length * 0.95) - 1,
+    singleIterLatencies.length - 1
+  )] : 0;
+  return {
+    totalRuns: runs.length,
+    approvalRate,
+    firstPassRate,
+    avgIterations: runs.reduce((s, r) => s + r.iterations, 0) / runs.length,
+    avgPlanLatencyMs: runs.reduce((s, r) => s + r.planLatencyMs, 0) / runs.length,
+    avgTotalLatencyMs: runs.reduce((s, r) => s + r.totalLatencyMs, 0) / runs.length,
+    p95PlanLatencyMs: p95Plan,
+    p95TotalLatencyMs: p95Total,
+    p95SingleIterLatencyMs: p95SingleIter,
+    editSuccessRate,
+    editFuzzyRate,
+    avgContextTokens,
+    passesTargets: {
+      planLatency: p95Plan <= HARNESS_TARGETS.planLatencyP95Ms,
+      totalLatency: p95Total <= HARNESS_TARGETS.totalLatencyP95Ms,
+      singleIterLatency: singleIterLatencies.length === 0 || p95SingleIter <= HARNESS_TARGETS.singleIterLatencyP95Ms,
+      firstPassApproval: firstPassRate >= HARNESS_TARGETS.firstPassApprovalRate,
+      editSuccess: editSuccessRate >= HARNESS_TARGETS.editSuccessRate,
+      editFuzzyRate: editFuzzyRate <= HARNESS_TARGETS.editFuzzyFallbackRate,
+      contextBudget: avgContextTokens <= HARNESS_TARGETS.contextTokenBudget
+    }
+  };
+}
+export {
+  HARNESS_TARGETS,
+  SWE_BENCH_BASELINES,
+  summarizeRuns
+};

package/dist/src/orchestrators/multimodal/constants.js

@@ -8,9 +8,17 @@ const DEFAULT_IMPLEMENTER = process.env.STACKMEMORY_MM_IMPLEMENTER || "codex";
 const DEFAULT_MAX_ITERS = Number(
   process.env.STACKMEMORY_MM_MAX_ITERS || 2
 );
+const STRUCTURED_RESPONSE_SUFFIX = `
+
+Response Format:
+- When asking a question, ALWAYS end with structured choices: Yes/No, or numbered options (1, 2, 3, 4), or lettered options (A, B, C, D).
+- When completing a task, end with "Done." followed by suggested next steps as numbered options (1, 2, 3, 4).
+- Never leave responses open-ended. Always provide explicit options the user can select.
+- Keep options concise (one line each). Use the format that best fits: Yes/No for confirmations, 1-4 for action choices, A-D for category selections.`;
 export {
   DEFAULT_IMPLEMENTER,
   DEFAULT_MAX_ITERS,
   DEFAULT_PLANNER_MODEL,
-  DEFAULT_REVIEWER_MODEL
+  DEFAULT_REVIEWER_MODEL,
+  STRUCTURED_RESPONSE_SUFFIX
 };

package/dist/src/orchestrators/multimodal/harness.js

@@ -2,11 +2,20 @@ import { fileURLToPath as __fileURLToPath } from 'url';
 import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
-import { callClaude, callCodexCLI, implementWithClaude } from "./providers.js";
+import {
+  callClaude,
+  callCodexCLI,
+  captureGitDiff,
+  implementWithClaude,
+  parseEditMetrics,
+  runPostImplChecks
+} from "./providers.js";
 import * as fs from "fs";
 import * as path from "path";
 import { FrameManager } from "../../core/context/index.js";
 import { deriveProjectId } from "./utils.js";
+import { HARNESS_TARGETS, summarizeRuns } from "./baselines.js";
+import { feedbackLoops } from "../../core/monitoring/feedback-loops.js";
 function heuristicPlan(input) {
   return {
     summary: `Plan for: ${input.task}`,
@@ -50,6 +59,7 @@ Repo: ${input.repoPath}
 Notes: ${input.contextNotes || "(none)"}
 ${contextSummary}
 Constraints: Keep the plan minimal and implementable in a single PR.`;
+  const t0 = Date.now();
   let plan;
   try {
     const raw = await callClaude(plannerPrompt, {
@@ -65,6 +75,7 @@ Constraints: Keep the plan minimal and implementable in a single PR.`;
   } catch {
     plan = heuristicPlan(input);
   }
+  const planLatencyMs = Date.now() - t0;
   const implementer = options.implementer || "codex";
   const maxIters = Math.max(1, options.maxIters ?? 2);
   const iterations = [];
@@ -104,11 +115,25 @@ Incorporate reviewer suggestions: ${lastCritique.suggestions.join("; ")}`;
       lastCommand = `claude:${options.plannerModel || "sonnet"} prompt`;
       lastOutput = impl.output;
     }
-    const criticSystem = `You are a strict code reviewer. Return a JSON object: { approved: boolean, issues: string[], suggestions: string[] }`;
+    const diff = options.dryRun !== false ? "(dry run \u2014 no diff)" : captureGitDiff(input.repoPath);
+    const checks = options.dryRun !== false ? null : runPostImplChecks(input.repoPath);
+    const checksSection = checks ? `
+
+Post-implementation checks:
+  Lint: ${checks.lintOk ? "PASS" : "FAIL"}
+${checks.lintOutput}
+  Tests: ${checks.testsOk ? "PASS" : "FAIL"}
+${checks.testOutput}` : "";
+    const criticSystem = `You are a strict code reviewer. Review the git diff against the plan. Check for: correctness, missing steps, unrelated changes, bugs, security issues. Also review lint and test results if provided. Return raw JSON only (no markdown fences): { "approved": boolean, "issues": ["string"], "suggestions": ["string"] }`;
     const criticPrompt = `Plan: ${plan.summary}
+Acceptance criteria:
+${plan.steps.map((s) => s.acceptanceCriteria?.join(", ") || s.title).join("\n")}
+
 Attempt ${i + 1}/${maxIters}
-Command: ${lastCommand}
-Output: ${lastOutput.slice(0, 2e3)}`;
+Implementer exit: ${ok ? "success" : "failed"}
+
+Git diff:
+${diff}${checksSection}`;
     try {
       const raw = await callClaude(criticPrompt, {
         model: options.reviewerModel,
@@ -126,7 +151,7 @@ Output: ${lastOutput.slice(0, 2e3)}`;
     iterations.push({
       command: lastCommand,
       ok,
-      outputPreview: lastOutput.slice(0, 400),
+      outputPreview: diff.slice(0, 2e3),
       critique: lastCritique
     });
     if (lastCritique.approved) {
@@ -134,6 +159,24 @@ Output: ${lastOutput.slice(0, 2e3)}`;
       break;
     }
   }
+  const totalLatencyMs = Date.now() - t0;
+  const finalDiff = options.dryRun !== false ? "(dry run \u2014 no diff)" : captureGitDiff(input.repoPath);
+  const editMetrics = parseEditMetrics(finalDiff);
+  const runMetrics = {
+    timestamp: Date.now(),
+    task: input.task,
+    plannerModel: options.plannerModel || "default",
+    reviewerModel: options.reviewerModel || "default",
+    implementer,
+    planLatencyMs,
+    totalLatencyMs,
+    iterations: iterations.length,
+    approved,
+    editAttempts: editMetrics.editAttempts,
+    editSuccesses: editMetrics.editSuccesses,
+    editFuzzyFallbacks: editMetrics.editFuzzyFallbacks,
+    contextTokens: Math.ceil(finalDiff.length / 4)
+  };
   try {
     const dir = options.auditDir || path.join(input.repoPath, ".stackmemory", "build");
     fs.mkdirSync(dir, { recursive: true });
@@ -146,12 +189,49 @@ Output: ${lastOutput.slice(0, 2e3)}`;
           input,
           options: { ...options, auditDir: void 0 },
           plan,
-          iterations
+          iterations,
+          metrics: runMetrics
         },
         null,
         2
       )
     );
+    const metricsFile = path.join(dir, "harness-metrics.jsonl");
+    fs.appendFileSync(metricsFile, JSON.stringify(runMetrics) + "\n");
+    try {
+      const lines = fs.readFileSync(metricsFile, "utf-8").split("\n").filter((l) => l.trim());
+      const recent = lines.slice(-10).map((l) => JSON.parse(l));
+      if (recent.length >= 3) {
+        const summary = summarizeRuns(recent);
+        if (summary.approvalRate < HARNESS_TARGETS.firstPassApprovalRate) {
+          feedbackLoops.fire(
+            "harnessRegression",
+            "metrics_append",
+            {
+              metric: "approvalRate",
+              current: summary.approvalRate,
+              target: HARNESS_TARGETS.firstPassApprovalRate,
+              window: recent.length
+            },
+            "regression_alert"
+          );
+        }
+        if (summary.p95TotalLatencyMs > HARNESS_TARGETS.totalLatencyP95Ms) {
+          feedbackLoops.fire(
+            "harnessRegression",
+            "metrics_append",
+            {
+              metric: "totalLatencyP95",
+              current: summary.p95TotalLatencyMs,
+              target: HARNESS_TARGETS.totalLatencyP95Ms,
+              window: recent.length
+            },
+            "regression_alert"
+          );
+        }
+      }
+    } catch {
+    }
   } catch {
   }
   if (options.record) {