@stackmemoryai/stackmemory 1.0.1 → 1.2.1

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

@@ -30,6 +30,8 @@ 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 { GraphitiClient } from "../graphiti/client.js";
+import { fuzzyEdit } from "../../utils/fuzzy-edit.js";
 import { v4 as uuidv4 } from "uuid";
 import {
   DEFAULT_PLANNER_MODEL,
@@ -62,6 +64,8 @@ class LocalStackMemoryMCP {
   contextRetrieval;
   discoveryHandlers;
   diffMemHandlers;
+  providerHandlers = null;
+  graphitiClient = null;
   pendingPlans = /* @__PURE__ */ new Map();
   constructor() {
     this.projectRoot = this.findProjectRoot();
@@ -91,6 +95,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 +138,16 @@ class LocalStackMemoryMCP {
       projectRoot: this.projectRoot
     });
     this.diffMemHandlers = new DiffMemHandlers();
+    this.initProviderHandlers();
+    if (process.env.GRAPHITI_ENDPOINT) {
+      this.graphitiClient = new GraphitiClient({
+        endpoint: process.env.GRAPHITI_ENDPOINT,
+        projectNamespace: process.env.STACKMEMORY_PROJECT_ID || this.projectId
+      });
+      logger.info("Graphiti client initialized", {
+        endpoint: process.env.GRAPHITI_ENDPOINT
+      });
+    }
     this.setupHandlers();
     this.loadInitialContext();
     this.loadPendingPlans();
@@ -243,6 +269,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 +1083,153 @@ ${summary}...`, 0.8);
                 type: "object",
                 properties: {}
               }
-            }
+            },
+            // Graphiti tools (only active when GRAPHITI_ENDPOINT is set)
+            ...this.graphitiClient ? [
+              {
+                name: "graphiti_status",
+                description: "Check Graphiti temporal knowledge graph connection status",
+                inputSchema: {
+                  type: "object",
+                  properties: {}
+                }
+              },
+              {
+                name: "graphiti_query",
+                description: "Query the Graphiti temporal knowledge graph for entities, relations, and episodes",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    query: {
+                      type: "string",
+                      description: "Semantic text query"
+                    },
+                    entityTypes: {
+                      type: "array",
+                      items: { type: "string" },
+                      description: 'Entity types to filter (e.g., ["Person", "File", "Issue"])'
+                    },
+                    validFrom: {
+                      type: "number",
+                      description: "Start of time window (epoch ms)"
+                    },
+                    validTo: {
+                      type: "number",
+                      description: "End of time window (epoch ms)"
+                    },
+                    maxHops: {
+                      type: "number",
+                      description: "Graph traversal depth (default 2)"
+                    },
+                    k: {
+                      type: "number",
+                      description: "Top-k results (default 20)"
+                    }
+                  }
+                }
+              }
+            ] : [],
+            // 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 +1377,111 @@ ${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;
+            // Graphiti tools
+            case "graphiti_status":
+              if (!this.graphitiClient) {
+                result = {
+                  content: [
+                    {
+                      type: "text",
+                      text: JSON.stringify({
+                        connected: false,
+                        message: "Graphiti integration disabled (GRAPHITI_ENDPOINT not set)"
+                      })
+                    }
+                  ]
+                };
+              } else {
+                const status = await this.graphitiClient.getStatus();
+                result = {
+                  content: [
+                    { type: "text", text: JSON.stringify(status, null, 2) }
+                  ]
+                };
+              }
+              break;
+            case "graphiti_query":
+              if (!this.graphitiClient) {
+                result = {
+                  content: [
+                    {
+                      type: "text",
+                      text: "Graphiti integration disabled (GRAPHITI_ENDPOINT not set)"
+                    }
+                  ]
+                };
+              } else {
+                const gCtx = await this.graphitiClient.queryTemporal({
+                  query: args.query,
+                  entityTypes: args.entityTypes,
+                  validFrom: args.validFrom,
+                  validTo: args.validTo,
+                  maxHops: args.maxHops,
+                  k: args.k
+                });
+                const text = gCtx.chunks.map((c) => c.text).join("\n\n");
+                result = {
+                  content: [
+                    {
+                      type: "text",
+                      text: text || `No results found (${gCtx.totalTokens} tokens searched)`
+                    }
+                  ]
+                };
+              }
+              break;
             default:
               throw new Error(`Unknown tool: ${name}`);
           }
@@ -2639,6 +2926,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,9 @@ class MCPToolDefinitions {
       ...this.getTaskTools(),
       ...this.getLinearTools(),
       ...this.getTraceTools(),
-      ...this.getDiscoveryTools()
+      ...this.getDiscoveryTools(),
+      ...this.getEditTools(),
+      ...this.getGraphitiTools()
     ];
   }
   /**
@@ -670,6 +672,89 @@ 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"]
+        }
+      }
+    ];
+  }
+  /**
+   * Graphiti knowledge graph tools
+   */
+  getGraphitiTools() {
+    return [
+      {
+        name: "graphiti_status",
+        description: "Check Graphiti temporal knowledge graph connection status",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "graphiti_query",
+        description: "Query the Graphiti temporal knowledge graph for entities, relations, and episodes",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Semantic text query"
+            },
+            entityTypes: {
+              type: "array",
+              items: { type: "string" },
+              description: 'Entity types to filter (e.g., ["Person", "File", "Issue"])'
+            },
+            validFrom: {
+              type: "number",
+              description: "Start of time window (epoch ms)"
+            },
+            validTo: {
+              type: "number",
+              description: "End of time window (epoch ms)"
+            },
+            maxHops: {
+              type: "number",
+              description: "Graph traversal depth (default 2)"
+            },
+            k: {
+              type: "number",
+              description: "Top-k results (default 20)"
+            }
+          }
+        }
+      }
+    ];
+  }
   /**
    * Get tool definition by name
    */
@@ -691,6 +776,10 @@ class MCPToolDefinitions {
         return this.getTraceTools();
       case "discovery":
         return this.getDiscoveryTools();
+      case "edit":
+        return this.getEditTools();
+      case "graphiti":
+        return this.getGraphitiTools();
       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
 };