@stackmemoryai/stackmemory 1.2.2 → 1.2.4

package/dist/src/integrations/mcp/handlers/cord-handlers.js

@@ -0,0 +1,397 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { randomUUID } from "crypto";
+import { logger } from "../../../core/monitoring/logger.js";
+class CordHandlers {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  MAX_DEPTH = 10;
+  MAX_TASKS = 50;
+  /**
+   * cord_spawn — create a child task with clean context (only blocker results visible)
+   */
+  async handleCordSpawn(args) {
+    return this.createTask(args, "spawn");
+  }
+  /**
+   * cord_fork — create a child task with full sibling context
+   */
+  async handleCordFork(args) {
+    return this.createTask(args, "fork");
+  }
+  /**
+   * cord_complete — mark a task as completed and unblock dependents
+   */
+  async handleCordComplete(args) {
+    try {
+      const { task_id, result } = args;
+      if (!task_id) throw new Error("task_id is required");
+      if (result === void 0 || result === null) {
+        throw new Error("result is required");
+      }
+      const db = this.deps.dbAdapter.getRawDatabase();
+      if (!db) throw new Error("Database not available");
+      const task = db.prepare("SELECT * FROM cord_tasks WHERE task_id = ?").get(task_id);
+      if (!task) throw new Error(`Task not found: ${task_id}`);
+      if (task.status === "completed") {
+        throw new Error(`Task already completed: ${task_id}`);
+      }
+      const now = Math.floor(Date.now() / 1e3);
+      db.prepare(
+        "UPDATE cord_tasks SET status = ?, result = ?, completed_at = ? WHERE task_id = ?"
+      ).run("completed", String(result), now, task_id);
+      const unblocked = this.checkAndUnblockDependents(db, task_id);
+      logger.info("Cord task completed", { task_id, unblocked });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Task ${task_id} completed.${unblocked.length > 0 ? ` Unblocked: ${unblocked.join(", ")}` : ""}`
+          }
+        ],
+        metadata: { task_id, status: "completed", unblocked }
+      };
+    } catch (error) {
+      logger.error(
+        "Error completing cord task",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  /**
+   * cord_ask — create an "ask" task (question with optional options)
+   */
+  async handleCordAsk(args) {
+    try {
+      const { question, options, parent_id } = args;
+      if (!question) throw new Error("question is required");
+      const db = this.deps.dbAdapter.getRawDatabase();
+      if (!db) throw new Error("Database not available");
+      const projectId = this.getProjectId();
+      const runId = this.getRunId();
+      const taskId = randomUUID();
+      this.checkTaskLimit(db, projectId);
+      let depth = 0;
+      if (parent_id) {
+        depth = this.computeDepth(db, parent_id);
+      }
+      const prompt = options ? JSON.stringify({ question, options }) : JSON.stringify({ question });
+      db.prepare(
+        `INSERT INTO cord_tasks (task_id, parent_id, project_id, run_id, goal, prompt, status, context_mode, depth)
+         VALUES (?, ?, ?, ?, ?, ?, 'asked', 'ask', ?)`
+      ).run(
+        taskId,
+        parent_id || null,
+        projectId,
+        runId,
+        question,
+        prompt,
+        depth
+      );
+      logger.info("Cord ask created", { task_id: taskId });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Ask created: ${taskId} \u2014 "${question}"`
+          }
+        ],
+        metadata: {
+          task_id: taskId,
+          status: "asked",
+          context_mode: "ask",
+          question,
+          options: options || null
+        }
+      };
+    } catch (error) {
+      logger.error(
+        "Error creating cord ask",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  /**
+   * cord_tree — view the task tree with context scoping
+   */
+  async handleCordTree(args) {
+    try {
+      const { task_id, include_results = false } = args;
+      const db = this.deps.dbAdapter.getRawDatabase();
+      if (!db) throw new Error("Database not available");
+      const projectId = this.getProjectId();
+      let tasks;
+      if (task_id) {
+        tasks = this.getSubtree(db, task_id);
+      } else {
+        tasks = db.prepare(
+          "SELECT * FROM cord_tasks WHERE project_id = ? ORDER BY depth ASC, created_at ASC"
+        ).all(projectId);
+      }
+      if (tasks.length === 0) {
+        return {
+          content: [{ type: "text", text: "No cord tasks found." }],
+          metadata: { tasks: [] }
+        };
+      }
+      const taskMap = /* @__PURE__ */ new Map();
+      for (const t of tasks) taskMap.set(t.task_id, t);
+      const allTasks = db.prepare(
+        "SELECT * FROM cord_tasks WHERE project_id = ? ORDER BY depth ASC, created_at ASC"
+      ).all(projectId);
+      const allTaskMap = /* @__PURE__ */ new Map();
+      for (const t of allTasks) allTaskMap.set(t.task_id, t);
+      const treeNodes = tasks.map((t) => {
+        const blockedBy = JSON.parse(t.blocked_by);
+        const node = {
+          task_id: t.task_id,
+          goal: t.goal,
+          status: t.status,
+          context_mode: t.context_mode,
+          depth: t.depth,
+          blocked_by: blockedBy,
+          parent_id: t.parent_id
+        };
+        if (include_results && t.result !== null) {
+          node.result = t.result;
+        }
+        node.visible_context = this.computeVisibleContext(
+          t,
+          allTaskMap,
+          include_results
+        );
+        return node;
+      });
+      const summary = tasks.map(
+        (t) => `${"  ".repeat(t.depth)}[${t.status}] ${t.goal}${t.context_mode === "ask" ? " (ask)" : ""}`
+      ).join("\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Cord Tree (${tasks.length} tasks):
+${summary}`
+          }
+        ],
+        metadata: { tasks: treeNodes }
+      };
+    } catch (error) {
+      logger.error(
+        "Error getting cord tree",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  // --- Private helpers ---
+  async createTask(args, contextMode) {
+    try {
+      const { goal, prompt = "", blocked_by = [], parent_id } = args;
+      if (!goal) throw new Error("goal is required");
+      const db = this.deps.dbAdapter.getRawDatabase();
+      if (!db) throw new Error("Database not available");
+      const projectId = this.getProjectId();
+      const runId = this.getRunId();
+      const taskId = randomUUID();
+      this.checkTaskLimit(db, projectId);
+      let depth = 0;
+      if (parent_id) {
+        depth = this.computeDepth(db, parent_id);
+      }
+      const blockerIds = Array.isArray(blocked_by) ? blocked_by : [];
+      if (blockerIds.length > 0) {
+        this.validateBlockers(db, blockerIds);
+        this.detectCircularDeps(db, taskId, blockerIds);
+      }
+      const status = this.initialStatus(db, blockerIds);
+      db.prepare(
+        `INSERT INTO cord_tasks (task_id, parent_id, project_id, run_id, goal, prompt, status, context_mode, blocked_by, depth)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        taskId,
+        parent_id || null,
+        projectId,
+        runId,
+        goal,
+        prompt,
+        status,
+        contextMode,
+        JSON.stringify(blockerIds),
+        depth
+      );
+      logger.info("Cord task created", {
+        task_id: taskId,
+        context_mode: contextMode,
+        status
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Task ${taskId} created (${contextMode}, ${status}): ${goal}`
+          }
+        ],
+        metadata: {
+          task_id: taskId,
+          status,
+          context_mode: contextMode,
+          depth,
+          blocked_by: blockerIds
+        }
+      };
+    } catch (error) {
+      logger.error(
+        "Error creating cord task",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      throw error;
+    }
+  }
+  checkTaskLimit(db, projectId) {
+    const row = db.prepare("SELECT COUNT(*) as count FROM cord_tasks WHERE project_id = ?").get(projectId);
+    if (row.count >= this.MAX_TASKS) {
+      throw new Error(
+        `Task limit reached: ${this.MAX_TASKS} tasks per project`
+      );
+    }
+  }
+  computeDepth(db, parentId) {
+    const parent = db.prepare("SELECT depth FROM cord_tasks WHERE task_id = ?").get(parentId);
+    if (!parent) throw new Error(`Parent task not found: ${parentId}`);
+    const depth = parent.depth + 1;
+    if (depth >= this.MAX_DEPTH) {
+      throw new Error(`Max depth exceeded: ${this.MAX_DEPTH}`);
+    }
+    return depth;
+  }
+  validateBlockers(db, blockerIds) {
+    for (const id of blockerIds) {
+      const exists = db.prepare("SELECT 1 FROM cord_tasks WHERE task_id = ?").get(id);
+      if (!exists) throw new Error(`Blocker task not found: ${id}`);
+    }
+  }
+  detectCircularDeps(db, newTaskId, blockerIds) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [...blockerIds];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current === newTaskId) {
+        throw new Error("Circular dependency detected");
+      }
+      if (visited.has(current)) continue;
+      visited.add(current);
+      const task = db.prepare("SELECT blocked_by FROM cord_tasks WHERE task_id = ?").get(current);
+      if (task) {
+        const deps = JSON.parse(task.blocked_by);
+        for (const dep of deps) {
+          if (!visited.has(dep)) queue.push(dep);
+        }
+      }
+    }
+  }
+  initialStatus(db, blockerIds) {
+    if (blockerIds.length === 0) return "active";
+    for (const id of blockerIds) {
+      const task = db.prepare("SELECT status FROM cord_tasks WHERE task_id = ?").get(id);
+      if (!task || task.status !== "completed") return "blocked";
+    }
+    return "active";
+  }
+  checkAndUnblockDependents(db, completedTaskId) {
+    const allBlocked = db.prepare("SELECT * FROM cord_tasks WHERE status = 'blocked'").all();
+    const unblocked = [];
+    for (const task of allBlocked) {
+      const blockers = JSON.parse(task.blocked_by);
+      if (!blockers.includes(completedTaskId)) continue;
+      const allDone = blockers.every((bid) => {
+        if (bid === completedTaskId) return true;
+        const blocker = db.prepare("SELECT status FROM cord_tasks WHERE task_id = ?").get(bid);
+        return blocker?.status === "completed";
+      });
+      if (allDone) {
+        db.prepare(
+          "UPDATE cord_tasks SET status = 'active' WHERE task_id = ?"
+        ).run(task.task_id);
+        unblocked.push(task.task_id);
+      }
+    }
+    return unblocked;
+  }
+  getSubtree(db, rootId) {
+    const result = [];
+    const queue = [rootId];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const task = db.prepare("SELECT * FROM cord_tasks WHERE task_id = ?").get(current);
+      if (task) {
+        result.push(task);
+        const children = db.prepare(
+          "SELECT task_id FROM cord_tasks WHERE parent_id = ? ORDER BY created_at ASC"
+        ).all(current);
+        for (const c of children) queue.push(c.task_id);
+      }
+    }
+    return result;
+  }
+  computeVisibleContext(task, allTaskMap, includeResults) {
+    const ctx = { prompt: task.prompt };
+    if (task.context_mode === "ask") {
+      try {
+        const parsed = JSON.parse(task.prompt);
+        ctx.question = parsed.question;
+        ctx.options = parsed.options || null;
+      } catch {
+        ctx.question = task.goal;
+      }
+      if (task.status === "completed" && task.result !== null) {
+        ctx.answer = task.result;
+      }
+      return ctx;
+    }
+    const blockerIds = JSON.parse(task.blocked_by);
+    const blockerResults = [];
+    for (const bid of blockerIds) {
+      const blocker = allTaskMap.get(bid);
+      if (blocker?.status === "completed" && blocker.result !== null) {
+        blockerResults.push({
+          task_id: bid,
+          goal: blocker.goal,
+          result: includeResults ? blocker.result : "[completed]"
+        });
+      }
+    }
+    if (blockerResults.length > 0) {
+      ctx.blocker_results = blockerResults;
+    }
+    if (task.context_mode === "fork" && task.parent_id) {
+      const siblingResults = [];
+      for (const [, t] of allTaskMap) {
+        if (t.parent_id === task.parent_id && t.task_id !== task.task_id && t.status === "completed" && t.result !== null) {
+          siblingResults.push({
+            task_id: t.task_id,
+            goal: t.goal,
+            result: includeResults ? t.result : "[completed]"
+          });
+        }
+      }
+      if (siblingResults.length > 0) {
+        ctx.sibling_results = siblingResults;
+      }
+    }
+    return ctx;
+  }
+  getProjectId() {
+    return this.deps.dbAdapter.projectId;
+  }
+  getRunId() {
+    return this.deps.frameManager.currentRunId;
+  }
+}
+export {
+  CordHandlers
+};

package/dist/src/integrations/mcp/handlers/index.js

@@ -18,6 +18,8 @@ import {
 import {
   ProviderHandlers
 } from "./provider-handlers.js";
+import { TeamHandlers } from "./team-handlers.js";
+import { CordHandlers } from "./cord-handlers.js";
 import {
   ContextHandlers as ContextHandlers2
 } from "./context-handlers.js";
@@ -27,12 +29,16 @@ import {
 } from "./linear-handlers.js";
 import { TraceHandlers as TraceHandlers2 } from "./trace-handlers.js";
 import { ProviderHandlers as ProviderHandlers2 } from "./provider-handlers.js";
+import { TeamHandlers as TeamHandlers2 } from "./team-handlers.js";
+import { CordHandlers as CordHandlers2 } from "./cord-handlers.js";
 class MCPHandlerFactory {
   contextHandlers;
   taskHandlers;
   linearHandlers;
   traceHandlers;
   providerHandlers;
+  teamHandlers;
+  cordHandlers;
   constructor(deps) {
     this.contextHandlers = new ContextHandlers2({
       frameManager: deps.frameManager
@@ -51,6 +57,16 @@ class MCPHandlerFactory {
       browserMCP: deps.browserMCP
     });
     this.providerHandlers = new ProviderHandlers2();
+    if (deps.dbAdapter) {
+      this.teamHandlers = new TeamHandlers2({
+        frameManager: deps.frameManager,
+        dbAdapter: deps.dbAdapter
+      });
+      this.cordHandlers = new CordHandlers2({
+        frameManager: deps.frameManager,
+        dbAdapter: deps.dbAdapter
+      });
+    }
   }
   /**
    * Get handler for a specific tool
@@ -130,6 +146,32 @@ class MCPHandlerFactory {
         return this.providerHandlers.handleBatchCheck.bind(
           this.providerHandlers
         );
+      // Team handlers
+      case "team_context_get":
+        if (!this.teamHandlers) throw new Error("Team tools require dbAdapter");
+        return this.teamHandlers.handleTeamContextGet.bind(this.teamHandlers);
+      case "team_context_share":
+        if (!this.teamHandlers) throw new Error("Team tools require dbAdapter");
+        return this.teamHandlers.handleTeamContextShare.bind(this.teamHandlers);
+      case "team_search":
+        if (!this.teamHandlers) throw new Error("Team tools require dbAdapter");
+        return this.teamHandlers.handleTeamSearch.bind(this.teamHandlers);
+      // Cord orchestration handlers
+      case "cord_spawn":
+        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
+        return this.cordHandlers.handleCordSpawn.bind(this.cordHandlers);
+      case "cord_fork":
+        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
+        return this.cordHandlers.handleCordFork.bind(this.cordHandlers);
+      case "cord_complete":
+        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
+        return this.cordHandlers.handleCordComplete.bind(this.cordHandlers);
+      case "cord_ask":
+        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
+        return this.cordHandlers.handleCordAsk.bind(this.cordHandlers);
+      case "cord_tree":
+        if (!this.cordHandlers) throw new Error("Cord tools require dbAdapter");
+        return this.cordHandlers.handleCordTree.bind(this.cordHandlers);
       default:
         throw new Error(`Unknown tool: ${toolName}`);
     }
@@ -167,7 +209,17 @@ class MCPHandlerFactory {
       // Provider tools (conditionally active)
       "delegate_to_model",
       "batch_submit",
-      "batch_check"
+      "batch_check",
+      // Team tools
+      "team_context_get",
+      "team_context_share",
+      "team_search",
+      // Cord orchestration tools
+      "cord_spawn",
+      "cord_fork",
+      "cord_complete",
+      "cord_ask",
+      "cord_tree"
     ];
   }
   /**
@@ -179,10 +231,12 @@ class MCPHandlerFactory {
 }
 export {
   ContextHandlers,
+  CordHandlers,
   DiscoveryHandlers,
   LinearHandlers,
   MCPHandlerFactory,
   ProviderHandlers,
   TaskHandlers,
+  TeamHandlers,
   TraceHandlers
 };

package/dist/src/integrations/mcp/handlers/task-handlers.js

@@ -12,7 +12,13 @@ class TaskHandlers {
    */
   async handleCreateTask(args) {
     try {
-      const { title, description, priority = "medium", tags = [], parent_id } = args;
+      const {
+        title,
+        description,
+        priority = "medium",
+        tags = [],
+        parent_id
+      } = args;
       if (!title) {
         throw new Error("Task title is required");
       }
@@ -40,7 +46,10 @@ class TaskHandlers {
         }
       };
     } catch (error) {
-      logger.error("Error creating task", error instanceof Error ? error : new Error(String(error)));
+      logger.error(
+        "Error creating task",
+        error instanceof Error ? error : new Error(String(error))
+      );
       throw error;
     }
   }
@@ -57,12 +66,20 @@ class TaskHandlers {
         throw new Error("Status is required");
       }
       const validStatus = this.validateStatus(status);
-      await this.deps.taskStore.updateTaskStatus(task_id, validStatus, progress);
+      await this.deps.taskStore.updateTaskStatus(
+        task_id,
+        validStatus,
+        progress
+      );
       const task = await this.deps.taskStore.getTask(task_id);
       if (!task) {
         throw new Error(`Task not found: ${task_id}`);
       }
-      logger.info("Updated task status", { taskId: task_id, status: validStatus, progress });
+      logger.info("Updated task status", {
+        taskId: task_id,
+        status: validStatus,
+        progress
+      });
       return {
         content: [
           {
@@ -77,7 +94,10 @@ class TaskHandlers {
         }
       };
     } catch (error) {
-      logger.error("Error updating task status", error instanceof Error ? error : new Error(String(error)));
+      logger.error(
+        "Error updating task status",
+        error instanceof Error ? error : new Error(String(error))
+      );
       throw error;
     }
   }
@@ -138,7 +158,10 @@ ${summaryText}`
         }
       };
     } catch (error) {
-      logger.error("Error getting active tasks", error instanceof Error ? error : new Error(String(error)));
+      logger.error(
+        "Error getting active tasks",
+        error instanceof Error ? error : new Error(String(error))
+      );
       throw error;
     }
   }
@@ -172,7 +195,10 @@ ${Object.entries(metrics.by_status || {}).map(([status, count]) => `- ${status}:
         metadata: metrics
       };
     } catch (error) {
-      logger.error("Error getting task metrics", error instanceof Error ? error : new Error(String(error)));
+      logger.error(
+        "Error getting task metrics",
+        error instanceof Error ? error : new Error(String(error))
+      );
       throw error;
     }
   }
@@ -191,7 +217,11 @@ ${Object.entries(metrics.by_status || {}).map(([status, count]) => `- ${status}:
       if (!task || !dependencyTask) {
         throw new Error("One or both tasks not found");
       }
-      logger.info("Added task dependency", { taskId: task_id, dependsOn: depends_on, type: dependency_type });
+      logger.info("Added task dependency", {
+        taskId: task_id,
+        dependsOn: depends_on,
+        type: dependency_type
+      });
       return {
         content: [
           {
@@ -206,7 +236,10 @@ ${Object.entries(metrics.by_status || {}).map(([status, count]) => `- ${status}:
         }
       };
     } catch (error) {
-      logger.error("Error adding task dependency", error instanceof Error ? error : new Error(String(error)));
+      logger.error(
+        "Error adding task dependency",
+        error instanceof Error ? error : new Error(String(error))
+      );
       throw error;
     }
   }
@@ -217,7 +250,9 @@ ${Object.entries(metrics.by_status || {}).map(([status, count]) => `- ${status}:
     const validPriorities = ["low", "medium", "high", "urgent"];
     const normalizedPriority = priority.toLowerCase();
     if (!validPriorities.includes(normalizedPriority)) {
-      throw new Error(`Invalid priority: ${priority}. Must be one of: ${validPriorities.join(", ")}`);
+      throw new Error(
+        `Invalid priority: ${priority}. Must be one of: ${validPriorities.join(", ")}`
+      );
     }
     return normalizedPriority;
   }
@@ -225,10 +260,18 @@ ${Object.entries(metrics.by_status || {}).map(([status, count]) => `- ${status}:
    * Validate task status
    */
   validateStatus(status) {
-    const validStatuses = ["pending", "in_progress", "blocked", "completed", "cancelled"];
+    const validStatuses = [
+      "pending",
+      "in_progress",
+      "blocked",
+      "completed",
+      "cancelled"
+    ];
     const normalizedStatus = status.toLowerCase().replace("_", "-");
     if (!validStatuses.includes(normalizedStatus)) {
-      throw new Error(`Invalid status: ${status}. Must be one of: ${validStatuses.join(", ")}`);
+      throw new Error(
+        `Invalid status: ${status}. Must be one of: ${validStatuses.join(", ")}`
+      );
     }
     return normalizedStatus;
   }