@stackmemoryai/stackmemory 1.12.0 → 1.14.0

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

@@ -23,7 +23,12 @@ import {
 } from "fs";
 import { homedir } from "os";
 import { compactPlan } from "../../orchestrators/multimodal/utils.js";
-import { filterPending } from "./pending-utils.js";
+import {
+  parseMasterTasks,
+  getNextTask,
+  addTaskToFile,
+  updateTaskInFile
+} from "../../core/tasks/md-task-parser.js";
 import { join, dirname } from "path";
 import { execSync } from "child_process";
 import { FrameManager } from "../../core/context/index.js";
@@ -35,9 +40,6 @@ import { BrowserMCPIntegration } from "../../features/browser/browser-mcp.js";
 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 { GreptileHandlers } from "./handlers/greptile-handlers.js";
-import { CrossSearchHandlers } from "./handlers/cross-search-handlers.js";
 import {
   generateChronologicalDigest
 } from "../../core/digest/chronological-digest.js";
@@ -79,13 +81,6 @@ const CACHEABLE_TOOLS = /* @__PURE__ */ new Set([
   "sm_cross_search",
   "sm_cross_discover",
   "sm_cross_list",
-  "diffmem_get_user_context",
-  "diffmem_search",
-  "diffmem_status",
-  "greptile_list_prs",
-  "greptile_pr_details",
-  "greptile_pr_comments",
-  "greptile_status",
   "linear_get_tasks",
   "linear_status",
   "provenant_search",
@@ -106,11 +101,7 @@ class LocalStackMemoryMCP {
   traceDetector;
   contextRetrieval;
   discoveryHandlers;
-  diffMemHandlers;
-  greptileHandlers;
   providerHandlers = null;
-  crossSearchHandlers;
-  pendingPlans = /* @__PURE__ */ new Map();
   contentCache;
   traceEventStore;
   sessionId;
@@ -190,10 +181,6 @@ class LocalStackMemoryMCP {
       db: this.db,
       projectRoot: this.projectRoot
     });
-    this.diffMemHandlers = new DiffMemHandlers();
-    this.greptileHandlers = new GreptileHandlers();
-    this.crossSearchHandlers = new CrossSearchHandlers({});
-    this.initProviderHandlers();
     this.setupHandlers();
     this.loadInitialContext();
     this.loadPendingPlans();
@@ -416,16 +403,6 @@ ${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({
@@ -454,7 +431,6 @@ ${summary}...`, 0.8);
             // Planning tools (only when ANTHROPIC_API_KEY is set)
             ...process.env.ANTHROPIC_API_KEY ? [
               {
-                name: "plan_gate",
                 description: "Phase 1: Generate a plan and return an approvalId for later execution",
                 inputSchema: {
                   type: "object",
@@ -472,14 +448,12 @@ ${summary}...`, 0.8);
                 }
               },
               {
-                name: "approve_plan",
                 description: "Phase 2: Execute a previously generated plan by approvalId",
                 inputSchema: {
                   type: "object",
                   properties: {
                     approvalId: {
-                      type: "string",
-                      description: "Id from plan_gate"
+                      type: "string"
                     },
                     implementer: {
                       type: "string",
@@ -558,15 +532,13 @@ ${summary}...`, 0.8);
                   type: "object",
                   properties: {
                     approvalId: {
-                      type: "string",
-                      description: "Approval id from plan_gate"
+                      type: "string"
                     }
                   },
                   required: ["approvalId"]
                 }
               },
               {
-                name: "plan_only",
                 description: "Generate an implementation plan (Claude) and return JSON only",
                 inputSchema: {
                   type: "object",
@@ -584,7 +556,6 @@ ${summary}...`, 0.8);
                 }
               },
               {
-                name: "call_codex",
                 description: "Invoke Codex via codex-sm with a prompt and args; dry-run by default",
                 inputSchema: {
                   type: "object",
@@ -608,7 +579,6 @@ ${summary}...`, 0.8);
                 }
               },
               {
-                name: "call_claude",
                 description: "Invoke Claude with a prompt (Anthropic SDK)",
                 inputSchema: {
                   type: "object",
@@ -1094,10 +1064,8 @@ ${summary}...`, 0.8);
                 required: ["query"]
               }
             },
-            // DiffMem tools (only when DIFFMEM_ENDPOINT or DIFFMEM_ENABLED is set)
             ...process.env.DIFFMEM_ENDPOINT || process.env.DIFFMEM_ENABLED === "true" ? this.diffMemHandlers.getToolDefinitions() : [],
             // Greptile tools (only active when GREPTILE_API_KEY is set)
-            ...process.env.GREPTILE_API_KEY ? this.greptileHandlers.getToolDefinitions() : [],
             // Provider tools (only active when STACKMEMORY_MULTI_PROVIDER=true)
             ...isFeatureEnabled("multiProvider") ? [
               {
@@ -1483,20 +1451,10 @@ ${summary}...`, 0.8);
             case "compress_old_traces":
               result = await this.handleCompressOldTraces(args);
               break;
-            case "plan_only":
-              result = await this.handlePlanOnly(args);
               break;
-            case "call_codex":
-              result = await this.handleCallCodex(args);
               break;
-            case "call_claude":
-              result = await this.handleCallClaude(args);
               break;
-            case "plan_gate":
-              result = await this.handlePlanGate(args);
               break;
-            case "approve_plan":
-              result = await this.handleApprovePlan(args);
               break;
             case "pending_list":
               result = await this.handlePendingList();
@@ -1526,41 +1484,15 @@ ${summary}...`, 0.8);
             case "sm_search":
               result = await this.handleSmSearch(args);
               break;
-            // DiffMem handlers
-            case "diffmem_get_user_context":
               result = await this.diffMemHandlers.handleGetUserContext(args);
               break;
-            case "diffmem_store_learning":
               result = await this.diffMemHandlers.handleStoreLearning(args);
               break;
-            case "diffmem_search":
               result = await this.diffMemHandlers.handleSearch(args);
               break;
-            case "diffmem_status":
               result = await this.diffMemHandlers.handleStatus();
               break;
             // Greptile handlers
-            case "greptile_pr_comments":
-              result = await this.greptileHandlers.handleListPRComments(args);
-              break;
-            case "greptile_pr_details":
-              result = await this.greptileHandlers.handleGetMergeRequest(args);
-              break;
-            case "greptile_list_prs":
-              result = await this.greptileHandlers.handleListPullRequests(args);
-              break;
-            case "greptile_trigger_review":
-              result = await this.greptileHandlers.handleTriggerCodeReview(args);
-              break;
-            case "greptile_search_patterns":
-              result = await this.greptileHandlers.handleSearchPatterns(args);
-              break;
-            case "greptile_create_pattern":
-              result = await this.greptileHandlers.handleCreatePattern(args);
-              break;
-            case "greptile_status":
-              result = await this.greptileHandlers.handleStatus();
-              break;
             case "sm_edit":
               result = await this.handleSmEdit(args);
               break;
@@ -1651,6 +1583,15 @@ ${summary}...`, 0.8);
             case "trace_event_annotate":
               result = this.handleTraceEventAnnotate(args);
               break;
+            case "get_next_master_task":
+              result = this.handleGetNextMasterTask(args);
+              break;
+            case "update_master_task":
+              result = this.handleUpdateMasterTask(args);
+              break;
+            case "create_master_task":
+              result = this.handleCreateMasterTask(args);
+              break;
             default:
               throw new Error(`Unknown tool: ${name}`);
           }
@@ -1795,60 +1736,6 @@ ${summary}...`, 0.8);
       isError: false
     };
   }
-  async handlePlanOnly(args) {
-    const { runPlanOnly } = await import("../../orchestrators/multimodal/harness.js");
-    const task = String(args.task || "Plan change");
-    const plannerModel = args.plannerModel || process.env["STACKMEMORY_MM_PLANNER_MODEL"] || DEFAULT_PLANNER_MODEL;
-    const plan = await runPlanOnly(
-      { task, repoPath: this.projectRoot },
-      { plannerModel }
-    );
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ ok: true, plan })
-        }
-      ],
-      isError: false
-    };
-  }
-  async handleCallCodex(args) {
-    const { callCodexCLI } = await import("../../orchestrators/multimodal/providers.js");
-    const prompt = String(args.prompt || "");
-    const extraArgs = Array.isArray(args.args) ? args.args : [];
-    const execute = Boolean(args.execute);
-    const resp = callCodexCLI(prompt, extraArgs, !execute);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            ok: resp.ok,
-            command: resp.command,
-            output: resp.output
-          })
-        }
-      ],
-      isError: false
-    };
-  }
-  async handleCallClaude(args) {
-    const { callClaude } = await import("../../orchestrators/multimodal/providers.js");
-    const prompt = String(args.prompt || "");
-    const model = args.model || process.env["STACKMEMORY_MM_PLANNER_MODEL"] || DEFAULT_PLANNER_MODEL;
-    const system = args.system || "You are a precise assistant. Return plain text unless asked for JSON.";
-    const text = await callClaude(prompt, { model, system });
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ ok: true, text })
-        }
-      ],
-      isError: false
-    };
-  }
   // Pending plan persistence (best-effort)
   getPendingStoreDir() {
     return join(this.projectRoot, ".stackmemory", "build");
@@ -1872,7 +1759,6 @@ ${summary}...`, 0.8);
       }
       const data = JSON.parse(readFileSync(sourceFile, "utf-8"));
       if (data && typeof data === "object") {
-        this.pendingPlans = new Map(Object.entries(data));
         if (sourceFile !== file) this.savePendingPlans();
       }
     } catch {
@@ -1883,214 +1769,11 @@ ${summary}...`, 0.8);
       const dir = this.getPendingStoreDir();
       if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
       const file = this.getPendingStorePath();
-      const obj = Object.fromEntries(this.pendingPlans);
       writeFileSync(file, JSON.stringify(obj, null, 2));
     } catch {
     }
   }
-  async handlePlanGate(args) {
-    const { runPlanOnly } = await import("../../orchestrators/multimodal/harness.js");
-    const task = String(args.task || "Plan change");
-    const plannerModel = args.plannerModel || process.env["STACKMEMORY_MM_PLANNER_MODEL"] || DEFAULT_PLANNER_MODEL;
-    const plan = await runPlanOnly(
-      { task, repoPath: this.projectRoot },
-      { plannerModel }
-    );
-    const approvalId = `appr_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    this.pendingPlans.set(approvalId, { task, plan, createdAt: Date.now() });
-    this.savePendingPlans();
-    const compact = Boolean(args.compact);
-    const planOut = compact ? compactPlan(plan) : plan;
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ ok: true, approvalId, plan: planOut })
-        }
-      ],
-      isError: false
-    };
-  }
-  async handleApprovePlan(args) {
-    const { runSpike } = await import("../../orchestrators/multimodal/harness.js");
-    const approvalId = String(args.approvalId || "");
-    const pending = this.pendingPlans.get(approvalId);
-    if (!pending) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ ok: false, error: "Invalid approvalId" })
-          }
-        ],
-        isError: false
-      };
-    }
-    const implementer = args.implementer || process.env["STACKMEMORY_MM_IMPLEMENTER"] || DEFAULT_IMPLEMENTER;
-    const maxIters = Number(
-      args.maxIters ?? process.env["STACKMEMORY_MM_MAX_ITERS"] ?? DEFAULT_MAX_ITERS
-    );
-    const recordFrame = args.recordFrame !== false;
-    const execute = args.execute !== false;
-    const verificationCommands = this.getVerificationCommands(args);
-    const result = await runSpike(
-      { task: pending.task, repoPath: this.projectRoot },
-      {
-        plannerModel: process.env["STACKMEMORY_MM_PLANNER_MODEL"] || DEFAULT_PLANNER_MODEL,
-        reviewerModel: process.env["STACKMEMORY_MM_REVIEWER_MODEL"] || process.env["STACKMEMORY_MM_PLANNER_MODEL"] || DEFAULT_PLANNER_MODEL,
-        implementer: implementer === "claude" ? "claude" : "codex",
-        maxIters: isFinite(maxIters) ? Math.max(1, maxIters) : 2,
-        dryRun: !execute,
-        verificationCommands,
-        recordFrame
-      }
-    );
-    this.pendingPlans.delete(approvalId);
-    this.savePendingPlans();
-    const compact = Boolean(args.compact);
-    const payload = compact ? { ...result, plan: compactPlan(result.plan) } : result;
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({ ok: true, approvalId, result: payload })
-        }
-      ],
-      isError: false
-    };
-  }
-  async handlePendingList(args) {
-    const schema = z.object({
-      taskContains: z.string().optional(),
-      olderThanMs: z.number().optional(),
-      newerThanMs: z.number().optional(),
-      sort: z.enum(["asc", "desc"]).optional(),
-      limit: z.number().int().positive().optional()
-    }).optional();
-    const parsed = schema.safeParse(args);
-    if (args && !parsed.success) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              ok: false,
-              error: "Invalid arguments",
-              details: parsed.error.issues
-            })
-          }
-        ],
-        isError: false
-      };
-    }
-    const a = parsed.success && parsed.data ? parsed.data : {};
-    const now = Date.now();
-    let items = Array.from(this.pendingPlans.entries()).map(
-      ([approvalId, data]) => ({
-        approvalId,
-        task: data?.task,
-        createdAt: Number(data?.createdAt || 0) || null
-      })
-    );
-    items = filterPending(items, a, now);
-    return {
-      content: [
-        { type: "text", text: JSON.stringify({ ok: true, pending: items }) }
-      ],
-      isError: false
-    };
-  }
-  async handlePendingClear(args) {
-    const removed = [];
-    const now = Date.now();
-    const all = Boolean(args?.all);
-    const approvalId = args?.approvalId ? String(args.approvalId) : void 0;
-    const olderThanMs = Number.isFinite(Number(args?.olderThanMs)) ? Number(args.olderThanMs) : void 0;
-    if (all) {
-      for (const id of this.pendingPlans.keys()) removed.push(id);
-      this.pendingPlans.clear();
-      this.savePendingPlans();
-      return {
-        content: [
-          { type: "text", text: JSON.stringify({ ok: true, removed }) }
-        ],
-        isError: false
-      };
-    }
-    if (approvalId) {
-      if (this.pendingPlans.has(approvalId)) {
-        this.pendingPlans.delete(approvalId);
-        removed.push(approvalId);
-        this.savePendingPlans();
-      }
-      return {
-        content: [
-          { type: "text", text: JSON.stringify({ ok: true, removed }) }
-        ],
-        isError: false
-      };
-    }
-    if (olderThanMs !== void 0 && olderThanMs >= 0) {
-      for (const [id, data] of this.pendingPlans.entries()) {
-        const ts = Number(data?.createdAt || 0);
-        if (ts && now - ts > olderThanMs) {
-          this.pendingPlans.delete(id);
-          removed.push(id);
-        }
-      }
-      this.savePendingPlans();
-      return {
-        content: [
-          { type: "text", text: JSON.stringify({ ok: true, removed }) }
-        ],
-        isError: false
-      };
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            ok: false,
-            error: "Specify approvalId, all=true, or olderThanMs"
-          })
-        }
-      ],
-      isError: false
-    };
-  }
-  async handlePendingShow(args) {
-    const approvalId = String(args?.approvalId || "");
-    const data = this.pendingPlans.get(approvalId);
-    if (!data) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ ok: false, error: "Invalid approvalId" })
-          }
-        ],
-        isError: false
-      };
-    }
-    const compact = Boolean(args.compact);
-    const planOut = compact ? compactPlan(data.plan) : data.plan;
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            ok: true,
-            approvalId,
-            task: data.task,
-            plan: planOut,
-            createdAt: data.createdAt || null
-          })
-        }
-      ],
-      isError: false
-    };
-  }
+  // [REMOVED in v1.14] Conductor/multimodal handlers + pending plan handlers
   async handleGetContext(args) {
     const { query: query2 = "", limit = 10 } = args;
     const contexts = Array.from(this.contexts.values()).sort((a, b) => b.importance - a.importance).slice(0, limit);
@@ -3456,6 +3139,110 @@ ${catLines.join("\n")}`
     process.on("SIGTERM", printCacheSummary);
     process.on("exit", printCacheSummary);
   }
+  // ── Master Task Handlers ───────────────────────────────────
+  resolveMasterTasksPath() {
+    const smPath = join(
+      this.projectRoot,
+      ".stackmemory",
+      "tasks",
+      "master-tasks.md"
+    );
+    if (existsSync(smPath)) return smPath;
+    const rootPath = join(this.projectRoot, "master-tasks.md");
+    if (existsSync(rootPath)) return rootPath;
+    return null;
+  }
+  handleGetNextMasterTask(args) {
+    const mdPath = this.resolveMasterTasksPath();
+    if (!mdPath) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: 'No master-tasks.md found. Run "stackmemory tasks init" to create one.'
+          }
+        ]
+      };
+    }
+    let tasks = parseMasterTasks(readFileSync(mdPath, "utf-8"));
+    if (args.owner) {
+      tasks = tasks.filter((t) => t.owner === String(args.owner));
+    }
+    const next = getNextTask(tasks);
+    if (!next) {
+      return {
+        content: [{ type: "text", text: "No actionable tasks found." }]
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(next, null, 2) }]
+    };
+  }
+  handleUpdateMasterTask(args) {
+    const mdPath = this.resolveMasterTasksPath();
+    if (!mdPath) {
+      return {
+        content: [{ type: "text", text: "No master-tasks.md found." }]
+      };
+    }
+    const taskId = String(args.task_id || "").toUpperCase();
+    if (!taskId) {
+      return {
+        content: [{ type: "text", text: "task_id is required." }],
+        isError: true
+      };
+    }
+    const updates = {};
+    if (args.status) updates.status = String(args.status);
+    if (args.priority) updates.priority = String(args.priority);
+    if (args.owner) updates.owner = String(args.owner);
+    if (args.branch_pr) updates.branchPr = String(args.branch_pr);
+    if (args.notes) updates.notes = String(args.notes);
+    if (args.sync) updates.sync = String(args.sync);
+    try {
+      updateTaskInFile(mdPath, taskId, updates);
+      return {
+        content: [{ type: "text", text: `Updated ${taskId}` }]
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: err.message }],
+        isError: true
+      };
+    }
+  }
+  handleCreateMasterTask(args) {
+    const mdPath = this.resolveMasterTasksPath();
+    if (!mdPath) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: 'No master-tasks.md found. Run "stackmemory tasks init" to create one.'
+          }
+        ]
+      };
+    }
+    const task = String(args.task || "");
+    if (!task) {
+      return {
+        content: [{ type: "text", text: "task description is required." }],
+        isError: true
+      };
+    }
+    const id = addTaskToFile(mdPath, {
+      priority: String(args.priority || "P1"),
+      status: "todo",
+      owner: String(args.owner || "@me"),
+      sync: String(args.sync || "local"),
+      task,
+      branchPr: "",
+      notes: String(args.notes || "")
+    });
+    return {
+      content: [{ type: "text", text: `Created ${id}: ${task}` }]
+    };
+  }
 }
 var server_default = LocalStackMemoryMCP;
 async function runMCPServer() {