@stackmemoryai/stackmemory 1.2.1 → 1.2.4

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

@@ -0,0 +1,456 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { DEFAULT_GREPTILE_CONFIG } from "../../greptile/config.js";
+import { GreptileClient, GreptileClientError } from "../../greptile/client.js";
+import { logger } from "../../../core/monitoring/logger.js";
+class GreptileHandlers {
+  config;
+  client = null;
+  constructor(deps) {
+    this.config = { ...DEFAULT_GREPTILE_CONFIG, ...deps?.config };
+    if (this.config.enabled && this.config.apiKey) {
+      try {
+        this.client = new GreptileClient(this.config);
+      } catch {
+        this.client = null;
+      }
+    }
+  }
+  getToolDefinitions() {
+    return [
+      {
+        name: "greptile_pr_comments",
+        description: "Get PR review comments from Greptile. Returns unaddressed comments with suggestedCode for auto-fix workflows.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: 'Repository full name (e.g., "owner/repo")'
+            },
+            remote: {
+              type: "string",
+              enum: ["github", "gitlab", "azure", "bitbucket"],
+              description: "Remote provider"
+            },
+            defaultBranch: {
+              type: "string",
+              description: 'Default branch (e.g., "main")'
+            },
+            prNumber: {
+              type: "number",
+              description: "Pull request number"
+            },
+            greptileGenerated: {
+              type: "boolean",
+              description: "Filter for only Greptile review comments"
+            },
+            addressed: {
+              type: "boolean",
+              description: "Filter by comment addressed status"
+            }
+          },
+          required: ["name", "remote", "defaultBranch", "prNumber"]
+        }
+      },
+      {
+        name: "greptile_pr_details",
+        description: "Get detailed PR information including metadata, statistics, and review analysis from Greptile.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: 'Repository full name (e.g., "owner/repo")'
+            },
+            remote: {
+              type: "string",
+              enum: ["github", "gitlab", "azure", "bitbucket"],
+              description: "Remote provider"
+            },
+            defaultBranch: {
+              type: "string",
+              description: "Default branch"
+            },
+            prNumber: {
+              type: "number",
+              description: "Pull request number"
+            }
+          },
+          required: ["name", "remote", "defaultBranch", "prNumber"]
+        }
+      },
+      {
+        name: "greptile_list_prs",
+        description: "List pull requests. Filter by repository, branch, author, or state.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: 'Repository full name (e.g., "owner/repo")'
+            },
+            remote: {
+              type: "string",
+              enum: ["github", "gitlab", "azure", "bitbucket"],
+              description: "Remote provider"
+            },
+            defaultBranch: {
+              type: "string",
+              description: "Default branch"
+            },
+            sourceBranch: {
+              type: "string",
+              description: "Filter by source branch name"
+            },
+            authorLogin: {
+              type: "string",
+              description: "Filter by PR author username"
+            },
+            state: {
+              type: "string",
+              enum: ["open", "closed", "merged"],
+              description: "Filter by PR state"
+            },
+            limit: {
+              type: "number",
+              description: "Max results (default 20)"
+            }
+          }
+        }
+      },
+      {
+        name: "greptile_trigger_review",
+        description: "Trigger a Greptile code review for a pull request.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: 'Repository full name (e.g., "owner/repo")'
+            },
+            remote: {
+              type: "string",
+              enum: ["github", "gitlab", "azure", "bitbucket"],
+              description: "Remote provider"
+            },
+            defaultBranch: {
+              type: "string",
+              description: "Default branch"
+            },
+            prNumber: {
+              type: "number",
+              description: "Pull request number"
+            },
+            branch: {
+              type: "string",
+              description: "Current working branch"
+            }
+          },
+          required: ["name", "remote", "prNumber"]
+        }
+      },
+      {
+        name: "greptile_search_patterns",
+        description: "Search custom coding patterns and instructions in Greptile.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query for pattern content"
+            },
+            limit: {
+              type: "number",
+              description: "Max results (default 10)"
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "greptile_create_pattern",
+        description: "Create a new custom coding pattern or instruction in Greptile.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            body: {
+              type: "string",
+              description: "Pattern content"
+            },
+            type: {
+              type: "string",
+              enum: ["CUSTOM_INSTRUCTION", "PATTERN"],
+              description: "Context type (default: CUSTOM_INSTRUCTION)"
+            },
+            scopes: {
+              type: "object",
+              description: "Boolean expression defining where this pattern applies"
+            }
+          },
+          required: ["body"]
+        }
+      },
+      {
+        name: "greptile_status",
+        description: "Check Greptile integration connection status.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      }
+    ];
+  }
+  async handleListPRComments(args) {
+    if (!this.client) return this.disabledResponse();
+    try {
+      const toolArgs = {
+        name: args.name,
+        remote: args.remote,
+        defaultBranch: args.defaultBranch,
+        prNumber: args.prNumber
+      };
+      if (args.greptileGenerated !== void 0)
+        toolArgs.greptileGenerated = args.greptileGenerated;
+      if (args.addressed !== void 0) toolArgs.addressed = args.addressed;
+      const result = await this.client.callTool(
+        "list_merge_request_comments",
+        toolArgs
+      );
+      let actionableCount = 0;
+      if (Array.isArray(result)) {
+        actionableCount = result.filter(
+          (c) => !c.addressed && (c.suggestedCode || typeof c.body === "string" && c.body.includes("```suggestion"))
+        ).length;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+          }
+        ],
+        metadata: { actionableCount, tool: "list_merge_request_comments" }
+      };
+    } catch (error) {
+      return this.handleError("listPRComments", error);
+    }
+  }
+  async handleGetMergeRequest(args) {
+    if (!this.client) return this.disabledResponse();
+    try {
+      const result = await this.client.callTool("get_merge_request", {
+        name: args.name,
+        remote: args.remote,
+        defaultBranch: args.defaultBranch,
+        prNumber: args.prNumber
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+          }
+        ],
+        metadata: { tool: "get_merge_request" }
+      };
+    } catch (error) {
+      return this.handleError("getMergeRequest", error);
+    }
+  }
+  async handleListPullRequests(args) {
+    if (!this.client) return this.disabledResponse();
+    try {
+      const toolArgs = {};
+      if (args.name) toolArgs.name = args.name;
+      if (args.remote) toolArgs.remote = args.remote;
+      if (args.defaultBranch) toolArgs.defaultBranch = args.defaultBranch;
+      if (args.sourceBranch) toolArgs.sourceBranch = args.sourceBranch;
+      if (args.authorLogin) toolArgs.authorLogin = args.authorLogin;
+      if (args.state) toolArgs.state = args.state;
+      if (args.limit) toolArgs.limit = args.limit;
+      const result = await this.client.callTool("list_pull_requests", toolArgs);
+      return {
+        content: [
+          {
+            type: "text",
+            text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+          }
+        ],
+        metadata: { tool: "list_pull_requests" }
+      };
+    } catch (error) {
+      return this.handleError("listPullRequests", error);
+    }
+  }
+  async handleTriggerCodeReview(args) {
+    if (!this.client) return this.disabledResponse();
+    try {
+      const toolArgs = {
+        name: args.name,
+        remote: args.remote,
+        prNumber: args.prNumber
+      };
+      if (args.defaultBranch) toolArgs.defaultBranch = args.defaultBranch;
+      if (args.branch) toolArgs.branch = args.branch;
+      const result = await this.client.callTool(
+        "trigger_code_review",
+        toolArgs
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+          }
+        ],
+        metadata: { tool: "trigger_code_review" }
+      };
+    } catch (error) {
+      return this.handleError("triggerCodeReview", error);
+    }
+  }
+  async handleSearchPatterns(args) {
+    if (!this.client) return this.disabledResponse();
+    try {
+      const toolArgs = { query: args.query };
+      if (args.limit) toolArgs.limit = args.limit;
+      const result = await this.client.callTool(
+        "search_custom_context",
+        toolArgs
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+          }
+        ],
+        metadata: { tool: "search_custom_context" }
+      };
+    } catch (error) {
+      return this.handleError("searchPatterns", error);
+    }
+  }
+  async handleCreatePattern(args) {
+    if (!this.client) return this.disabledResponse();
+    try {
+      const toolArgs = { body: args.body };
+      if (args.type) toolArgs.type = args.type;
+      if (args.scopes) toolArgs.scopes = args.scopes;
+      const result = await this.client.callTool(
+        "create_custom_context",
+        toolArgs
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+          }
+        ],
+        metadata: { tool: "create_custom_context" }
+      };
+    } catch (error) {
+      return this.handleError("createPattern", error);
+    }
+  }
+  async handleStatus() {
+    if (!this.client) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                connected: false,
+                message: "Greptile integration disabled (GREPTILE_API_KEY not set)"
+              },
+              null,
+              2
+            )
+          }
+        ],
+        metadata: { connected: false }
+      };
+    }
+    try {
+      await this.client.callTool("list_pull_requests", { limit: 1 });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                connected: true,
+                endpoint: this.config.mcpEndpoint
+              },
+              null,
+              2
+            )
+          }
+        ],
+        metadata: { connected: true }
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                connected: false,
+                error: msg,
+                endpoint: this.config.mcpEndpoint
+              },
+              null,
+              2
+            )
+          }
+        ],
+        metadata: { connected: false, error: msg }
+      };
+    }
+  }
+  disabledResponse() {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Greptile integration disabled (GREPTILE_API_KEY not set)"
+        }
+      ]
+    };
+  }
+  handleError(operation, error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    const isConnectionError = msg.includes("ECONNREFUSED") || msg.includes("fetch failed") || msg.includes("network") || error instanceof GreptileClientError;
+    logger.debug(`Greptile ${operation} failed`, { error: msg });
+    if (isConnectionError) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Greptile unavailable (${operation}). The service may be temporarily unreachable.`
+          }
+        ],
+        metadata: { error: true, unavailable: true, operation }
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Greptile ${operation} error: ${msg}`
+        }
+      ],
+      metadata: { error: true, operation, message: msg }
+    };
+  }
+}
+export {
+  GreptileHandlers
+};

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;
   }