@stackmemoryai/stackmemory 1.2.7 → 1.2.8

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

@@ -31,6 +31,12 @@ 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 { CordHandlers } from "./handlers/cord-handlers.js";
+import { TeamHandlers } from "./handlers/team-handlers.js";
+import { SQLiteAdapter } from "../../core/database/sqlite-adapter.js";
+import {
+  generateChronologicalDigest
+} from "../../core/digest/chronological-digest.js";
 import { fuzzyEdit } from "../../utils/fuzzy-edit.js";
 import { v4 as uuidv4 } from "uuid";
 import {
@@ -66,6 +72,8 @@ class LocalStackMemoryMCP {
   diffMemHandlers;
   greptileHandlers;
   providerHandlers = null;
+  cordHandlers = null;
+  teamHandlers = null;
   pendingPlans = /* @__PURE__ */ new Map();
   constructor() {
     this.projectRoot = this.findProjectRoot();
@@ -139,6 +147,7 @@ class LocalStackMemoryMCP {
     });
     this.diffMemHandlers = new DiffMemHandlers();
     this.greptileHandlers = new GreptileHandlers();
+    this.initCordTeamHandlers();
     this.initProviderHandlers();
     this.setupHandlers();
     this.loadInitialContext();
@@ -261,6 +270,27 @@ ${summary}...`, 0.8);
       this.contexts.set(ctx.id, ctx);
     });
   }
+  async initCordTeamHandlers() {
+    try {
+      const dbPath = join(this.projectRoot, ".stackmemory", "context.db");
+      const adapter = new SQLiteAdapter(this.projectId, {
+        dbPath,
+        walMode: true
+      });
+      await adapter.connect();
+      this.cordHandlers = new CordHandlers({
+        frameManager: this.frameManager,
+        dbAdapter: adapter
+      });
+      this.teamHandlers = new TeamHandlers({
+        frameManager: this.frameManager,
+        dbAdapter: adapter
+      });
+      logger.info("Cord and Team handlers initialized");
+    } catch (error) {
+      logger.warn("Failed to initialize Cord/Team handlers", { error });
+    }
+  }
   async initProviderHandlers() {
     if (!isFeatureEnabled("multiProvider")) return;
     try {
@@ -296,199 +326,180 @@ ${summary}...`, 0.8);
                 }
               }
             },
-            {
-              name: "plan_and_code",
-              description: "Generate a plan (Claude), attempt implementation (Codex/Claude), and return JSON result. Quiet by default.",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  task: { type: "string", description: "Task description" },
-                  implementer: {
-                    type: "string",
-                    enum: ["codex", "claude"],
-                    default: "codex",
-                    description: "Which agent implements code"
-                  },
-                  maxIters: {
-                    type: "number",
-                    default: 2,
-                    description: "Retry loop iterations"
-                  },
-                  execute: {
-                    type: "boolean",
-                    default: false,
-                    description: "Actually call implementer (otherwise dry-run)"
+            // 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",
+                  properties: {
+                    task: {
+                      type: "string",
+                      description: "Task description"
+                    },
+                    plannerModel: {
+                      type: "string",
+                      description: "Claude model (optional)"
+                    }
                   },
-                  record: {
-                    type: "boolean",
-                    default: false,
-                    description: "Record plan & critique into StackMemory context"
+                  required: ["task"]
+                }
+              },
+              {
+                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"
+                    },
+                    implementer: {
+                      type: "string",
+                      enum: ["codex", "claude"],
+                      default: "codex",
+                      description: "Which agent implements code"
+                    },
+                    maxIters: { type: "number", default: 2 },
+                    recordFrame: { type: "boolean", default: true },
+                    execute: { type: "boolean", default: true }
                   },
-                  recordFrame: {
-                    type: "boolean",
-                    default: false,
-                    description: "Record as real frame with anchors"
+                  required: ["approvalId"]
+                }
+              },
+              {
+                name: "pending_list",
+                description: "List pending approval-gated plans (supports filters)",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    taskContains: {
+                      type: "string",
+                      description: "Filter tasks containing this substring"
+                    },
+                    olderThanMs: {
+                      type: "number",
+                      description: "Only items older than this age (ms)"
+                    },
+                    newerThanMs: {
+                      type: "number",
+                      description: "Only items newer than this age (ms)"
+                    },
+                    sort: {
+                      type: "string",
+                      enum: ["asc", "desc"],
+                      description: "Sort by createdAt"
+                    },
+                    limit: {
+                      type: "number",
+                      description: "Max items to return"
+                    }
                   }
-                },
-                required: ["task"]
-              }
-            },
-            {
-              name: "plan_gate",
-              description: "Phase 1: Generate a plan and return an approvalId for later execution",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  task: { type: "string", description: "Task description" },
-                  plannerModel: {
-                    type: "string",
-                    description: "Claude model (optional)"
+                }
+              },
+              {
+                name: "pending_clear",
+                description: "Clear pending approval-gated plans (by id, all, or olderThanMs)",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    approvalId: {
+                      type: "string",
+                      description: "Clear a single approval by id"
+                    },
+                    all: {
+                      type: "boolean",
+                      description: "Clear all pending approvals",
+                      default: false
+                    },
+                    olderThanMs: {
+                      type: "number",
+                      description: "Clear approvals older than this age (ms)"
+                    }
                   }
-                },
-                required: ["task"]
-              }
-            },
-            {
-              name: "approve_plan",
-              description: "Phase 2: Execute a previously generated plan by approvalId (runs implement + critique)",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  approvalId: {
-                    type: "string",
-                    description: "Id from plan_gate"
-                  },
-                  implementer: {
-                    type: "string",
-                    enum: ["codex", "claude"],
-                    default: "codex",
-                    description: "Which agent implements code"
-                  },
-                  maxIters: { type: "number", default: 2 },
-                  recordFrame: { type: "boolean", default: true },
-                  execute: { type: "boolean", default: true }
-                },
-                required: ["approvalId"]
-              }
-            },
-            {
-              name: "pending_list",
-              description: "List pending approval-gated plans (supports filters)",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  taskContains: {
-                    type: "string",
-                    description: "Filter tasks containing this substring"
-                  },
-                  olderThanMs: {
-                    type: "number",
-                    description: "Only items older than this age (ms)"
-                  },
-                  newerThanMs: {
-                    type: "number",
-                    description: "Only items newer than this age (ms)"
-                  },
-                  sort: {
-                    type: "string",
-                    enum: ["asc", "desc"],
-                    description: "Sort by createdAt"
-                  },
-                  limit: { type: "number", description: "Max items to return" }
                 }
-              }
-            },
-            {
-              name: "pending_clear",
-              description: "Clear pending approval-gated plans (by id, all, or olderThanMs)",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  approvalId: {
-                    type: "string",
-                    description: "Clear a single approval by id"
+              },
+              {
+                name: "pending_show",
+                description: "Show a pending plan by approvalId",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    approvalId: {
+                      type: "string",
+                      description: "Approval id from plan_gate"
+                    }
                   },
-                  all: {
-                    type: "boolean",
-                    description: "Clear all pending approvals",
-                    default: false
+                  required: ["approvalId"]
+                }
+              },
+              {
+                name: "plan_only",
+                description: "Generate an implementation plan (Claude) and return JSON only",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    task: {
+                      type: "string",
+                      description: "Task description"
+                    },
+                    plannerModel: {
+                      type: "string",
+                      description: "Claude model for planning (optional)"
+                    }
                   },
-                  olderThanMs: {
-                    type: "number",
-                    description: "Clear approvals older than this age (ms)"
-                  }
+                  required: ["task"]
                 }
-              }
-            },
-            {
-              name: "pending_show",
-              description: "Show a pending plan by approvalId",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  approvalId: {
-                    type: "string",
-                    description: "Approval id from plan_gate"
-                  }
-                },
-                required: ["approvalId"]
-              }
-            },
-            {
-              name: "plan_only",
-              description: "Generate an implementation plan (Claude) and return JSON only",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  task: { type: "string", description: "Task description" },
-                  plannerModel: {
-                    type: "string",
-                    description: "Claude model for planning (optional)"
-                  }
-                },
-                required: ["task"]
-              }
-            },
-            {
-              name: "call_codex",
-              description: "Invoke Codex via codex-sm with a prompt and args; dry-run by default",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  prompt: { type: "string", description: "Prompt for Codex" },
-                  args: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Additional CLI args for codex-sm"
+              },
+              {
+                name: "call_codex",
+                description: "Invoke Codex via codex-sm with a prompt and args; dry-run by default",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    prompt: {
+                      type: "string",
+                      description: "Prompt for Codex"
+                    },
+                    args: {
+                      type: "array",
+                      items: { type: "string" },
+                      description: "Additional CLI args for codex-sm"
+                    },
+                    execute: {
+                      type: "boolean",
+                      default: false,
+                      description: "Actually run codex-sm (otherwise dry-run)"
+                    }
                   },
-                  execute: {
-                    type: "boolean",
-                    default: false,
-                    description: "Actually run codex-sm (otherwise dry-run)"
-                  }
-                },
-                required: ["prompt"]
-              }
-            },
-            {
-              name: "call_claude",
-              description: "Invoke Claude with a prompt (Anthropic SDK)",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  prompt: { type: "string", description: "Prompt for Claude" },
-                  model: {
-                    type: "string",
-                    description: "Claude model (optional)"
+                  required: ["prompt"]
+                }
+              },
+              {
+                name: "call_claude",
+                description: "Invoke Claude with a prompt (Anthropic SDK)",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    prompt: {
+                      type: "string",
+                      description: "Prompt for Claude"
+                    },
+                    model: {
+                      type: "string",
+                      description: "Claude model (optional)"
+                    },
+                    system: {
+                      type: "string",
+                      description: "System prompt (optional)"
+                    }
                   },
-                  system: {
-                    type: "string",
-                    description: "System prompt (optional)"
-                  }
-                },
-                required: ["prompt"]
+                  required: ["prompt"]
+                }
               }
-            },
+            ] : [],
             {
               name: "add_decision",
               description: "Record a decision or important information",
@@ -953,109 +964,190 @@ ${summary}...`, 0.8);
                 required: ["query"]
               }
             },
-            // DiffMem tools for user memory management
+            // DiffMem tools (only when DIFFMEM_ENDPOINT or DIFFMEM_ENABLED is set)
+            ...process.env.DIFFMEM_ENDPOINT || process.env.DIFFMEM_ENABLED === "true" ? this.diffMemHandlers.getToolDefinitions() : [],
+            // Cord task orchestration tools
             {
-              name: "diffmem_get_user_context",
-              description: "Fetch user knowledge and preferences from memory. Use to personalize responses based on learned user patterns.",
+              name: "cord_spawn",
+              description: "Create a subtask with clean context (spawn). Child sees only its prompt and completed blocker results.",
               inputSchema: {
                 type: "object",
                 properties: {
-                  categories: {
+                  goal: {
+                    type: "string",
+                    description: "What this task should accomplish"
+                  },
+                  prompt: {
+                    type: "string",
+                    description: "Detailed instructions for the task"
+                  },
+                  blocked_by: {
                     type: "array",
-                    items: {
-                      type: "string",
-                      enum: [
-                        "preference",
-                        "expertise",
-                        "project_knowledge",
-                        "pattern",
-                        "correction"
-                      ]
-                    },
-                    description: "Filter by memory categories"
+                    items: { type: "string" },
+                    description: "Task IDs that must complete first"
                   },
-                  limit: {
-                    type: "number",
-                    default: 10,
-                    description: "Maximum memories to return"
-                  }
-                }
+                  parent_id: { type: "string", description: "Parent task ID" }
+                },
+                required: ["goal"]
               }
             },
             {
-              name: "diffmem_store_learning",
-              description: "Store a new insight about the user (preference, expertise, pattern, or correction)",
+              name: "cord_fork",
+              description: "Create a subtask with full sibling context (fork). Child sees prompt, blocker results, AND completed sibling results.",
               inputSchema: {
                 type: "object",
                 properties: {
-                  content: {
+                  goal: {
                     type: "string",
-                    description: "The insight to store"
+                    description: "What this task should accomplish"
                   },
-                  category: {
+                  prompt: {
                     type: "string",
-                    enum: [
-                      "preference",
-                      "expertise",
-                      "project_knowledge",
-                      "pattern",
-                      "correction"
-                    ],
-                    description: "Category of the insight"
+                    description: "Detailed instructions for the task"
                   },
-                  confidence: {
-                    type: "number",
-                    minimum: 0,
-                    maximum: 1,
-                    default: 0.7,
-                    description: "Confidence level (0-1)"
+                  blocked_by: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Task IDs that must complete first"
                   },
-                  context: {
-                    type: "object",
-                    description: "Additional context for the insight"
-                  }
+                  parent_id: { type: "string", description: "Parent task ID" }
                 },
-                required: ["content", "category"]
+                required: ["goal"]
               }
             },
             {
-              name: "diffmem_search",
-              description: "Semantic search across user memories. Find relevant past insights and preferences.",
+              name: "cord_complete",
+              description: "Mark a cord task as completed with a result. Automatically unblocks dependent tasks.",
               inputSchema: {
                 type: "object",
                 properties: {
-                  query: {
+                  task_id: {
                     type: "string",
-                    description: "Search query"
+                    description: "Task ID to complete"
                   },
-                  timeRange: {
+                  result: {
                     type: "string",
-                    enum: ["day", "week", "month", "all"],
-                    default: "all",
-                    description: "Time range filter"
+                    description: "The result/output of this task"
+                  }
+                },
+                required: ["task_id", "result"]
+              }
+            },
+            {
+              name: "cord_ask",
+              description: "Create an ask task \u2014 a question that needs an answer before dependent tasks can proceed.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  question: {
+                    type: "string",
+                    description: "The question to ask"
                   },
-                  minConfidence: {
-                    type: "number",
-                    minimum: 0,
-                    maximum: 1,
-                    default: 0.5,
-                    description: "Minimum confidence threshold"
+                  options: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional list of answer choices"
+                  },
+                  parent_id: { type: "string", description: "Parent task ID" }
+                },
+                required: ["question"]
+              }
+            },
+            {
+              name: "cord_tree",
+              description: "View the cord task tree with context scoping. Shows active, blocked, or completed tasks.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  task_id: {
+                    type: "string",
+                    description: "Root task ID to show subtree (omit for full tree)"
                   },
+                  include_results: {
+                    type: "boolean",
+                    default: false,
+                    description: "Include task results in output"
+                  }
+                }
+              }
+            },
+            // Team collaboration tools
+            {
+              name: "team_context_get",
+              description: "Get context from other agents working on the same project. Returns recent frames and shared anchors.",
+              inputSchema: {
+                type: "object",
+                properties: {
                   limit: {
                     type: "number",
                     default: 10,
-                    description: "Maximum results"
+                    description: "Max frames to return"
+                  },
+                  types: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Filter by frame types"
+                  },
+                  since: {
+                    type: "number",
+                    description: "Only frames created after this timestamp (epoch ms)"
+                  }
+                }
+              }
+            },
+            {
+              name: "team_context_share",
+              description: "Share a piece of context with other agents. Creates a high-priority anchor visible to team_context_get.",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  content: {
+                    type: "string",
+                    description: "The context to share"
+                  },
+                  type: {
+                    type: "string",
+                    enum: [
+                      "FACT",
+                      "DECISION",
+                      "CONSTRAINT",
+                      "INTERFACE_CONTRACT",
+                      "TODO",
+                      "RISK"
+                    ],
+                    default: "FACT",
+                    description: "Type of context"
+                  },
+                  priority: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 10,
+                    default: 8,
+                    description: "Priority level (1-10)"
                   }
                 },
-                required: ["query"]
+                required: ["content"]
               }
             },
             {
-              name: "diffmem_status",
-              description: "Check DiffMem connection status and memory statistics",
+              name: "team_search",
+              description: "Search across all agents' context in the project. Uses full-text search across all sessions.",
               inputSchema: {
                 type: "object",
-                properties: {}
+                properties: {
+                  query: { type: "string", description: "Search query" },
+                  limit: {
+                    type: "number",
+                    default: 20,
+                    description: "Maximum results to return"
+                  },
+                  include_events: {
+                    type: "boolean",
+                    default: false,
+                    description: "Include events in results"
+                  }
+                },
+                required: ["query"]
               }
             },
             // Greptile tools (only active when GREPTILE_API_KEY is set)
@@ -1160,7 +1252,23 @@ ${summary}...`, 0.8);
                   required: ["batchId"]
                 }
               }
-            ] : []
+            ] : [],
+            // Digest tool
+            {
+              name: "sm_digest",
+              description: "Generate a chronological activity digest for a time period (today/yesterday/week)",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  period: {
+                    type: "string",
+                    enum: ["today", "yesterday", "week"],
+                    description: "Time period for the digest"
+                  }
+                },
+                required: ["period"]
+              }
+            }
           ]
         };
       }
@@ -1330,6 +1438,96 @@ ${summary}...`, 0.8);
             case "sm_edit":
               result = await this.handleSmEdit(args);
               break;
+            // Cord task orchestration
+            case "cord_spawn":
+              if (!this.cordHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Cord handlers not initialized." }
+                  ]
+                };
+              } else {
+                result = await this.cordHandlers.handleCordSpawn(args);
+              }
+              break;
+            case "cord_fork":
+              if (!this.cordHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Cord handlers not initialized." }
+                  ]
+                };
+              } else {
+                result = await this.cordHandlers.handleCordFork(args);
+              }
+              break;
+            case "cord_complete":
+              if (!this.cordHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Cord handlers not initialized." }
+                  ]
+                };
+              } else {
+                result = await this.cordHandlers.handleCordComplete(args);
+              }
+              break;
+            case "cord_ask":
+              if (!this.cordHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Cord handlers not initialized." }
+                  ]
+                };
+              } else {
+                result = await this.cordHandlers.handleCordAsk(args);
+              }
+              break;
+            case "cord_tree":
+              if (!this.cordHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Cord handlers not initialized." }
+                  ]
+                };
+              } else {
+                result = await this.cordHandlers.handleCordTree(args);
+              }
+              break;
+            // Team collaboration
+            case "team_context_get":
+              if (!this.teamHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Team handlers not initialized." }
+                  ]
+                };
+              } else {
+                result = await this.teamHandlers.handleTeamContextGet(args);
+              }
+              break;
+            case "team_context_share":
+              if (!this.teamHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Team handlers not initialized." }
+                  ]
+                };
+              } else {
+                result = await this.teamHandlers.handleTeamContextShare(args);
+              }
+              break;
+            case "team_search":
+              if (!this.teamHandlers) {
+                result = {
+                  content: [
+                    { type: "text", text: "Team handlers not initialized." }
+                  ]
+                };
+              } else {
+                result = await this.teamHandlers.handleTeamSearch(args);
+              }
+              break;
             // Provider tools
             case "delegate_to_model":
               if (!this.providerHandlers) {
@@ -1379,6 +1577,9 @@ ${summary}...`, 0.8);
                 );
               }
               break;
+            case "sm_digest":
+              result = await this.handleSmDigest(args);
+              break;
             default:
               throw new Error(`Unknown tool: ${name}`);
           }
@@ -2851,6 +3052,31 @@ ${typeBreakdown}`
       matchedText: editResult.match.matchedText.length > 200 ? editResult.match.matchedText.slice(0, 200) + "..." : editResult.match.matchedText
     };
   }
+  async handleSmDigest(args) {
+    const period = String(args.period || "today");
+    if (!["today", "yesterday", "week"].includes(period)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Invalid period "${period}". Use: today, yesterday, week`
+          }
+        ],
+        isError: true
+      };
+    }
+    const markdown = generateChronologicalDigest(
+      this.db,
+      period,
+      this.projectId
+    );
+    const outputPath = join(this.projectRoot, ".stackmemory", `${period}.md`);
+    writeFileSync(outputPath, markdown);
+    return {
+      content: [{ type: "text", text: markdown }],
+      isError: false
+    };
+  }
   async start() {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);