@stackmemoryai/stackmemory 1.2.1 → 1.2.2

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/server.js

@@ -30,6 +30,7 @@ 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 { GraphitiClient } from "../graphiti/client.js";
 import { fuzzyEdit } from "../../utils/fuzzy-edit.js";
 import { v4 as uuidv4 } from "uuid";
@@ -64,6 +65,7 @@ class LocalStackMemoryMCP {
   contextRetrieval;
   discoveryHandlers;
   diffMemHandlers;
+  greptileHandlers;
   providerHandlers = null;
   graphitiClient = null;
   pendingPlans = /* @__PURE__ */ new Map();
@@ -138,6 +140,7 @@ class LocalStackMemoryMCP {
       projectRoot: this.projectRoot
     });
     this.diffMemHandlers = new DiffMemHandlers();
+    this.greptileHandlers = new GreptileHandlers();
     this.initProviderHandlers();
     if (process.env.GRAPHITI_ENDPOINT) {
       this.graphitiClient = new GraphitiClient({
@@ -1129,6 +1132,8 @@ ${summary}...`, 0.8);
                 }
               }
             ] : [],
+            // 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") ? [
               {
@@ -1377,6 +1382,28 @@ ${summary}...`, 0.8);
             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;

package/dist/src/skills/claude-skills.js

@@ -948,6 +948,25 @@ class ClaudeSkillsManager {
             };
         }
       }
+      case "agent": {
+        const { ParallelAgentSkill } = await import("./parallel-agent-skill.js");
+        const agentSkill = new ParallelAgentSkill(this.context);
+        const sub = args[0];
+        const agentOpts = { timeout: options?.timeout };
+        switch (sub) {
+          case "research":
+            return agentSkill.research(args.slice(1).join(" "), agentOpts);
+          case "maintain":
+            return agentSkill.maintain(args.slice(1).join(" "), agentOpts);
+          case "spec-run":
+            return agentSkill.specRun(args[1], agentOpts);
+          default:
+            return {
+              success: false,
+              message: `Unknown: agent ${sub}. Use: research|maintain|spec-run`
+            };
+        }
+      }
       case "linear-run": {
         if (!this.linearTaskRunner) {
           return {
@@ -983,7 +1002,15 @@ class ClaudeSkillsManager {
     }
   }
   getAvailableSkills() {
-    const skills = ["handoff", "checkpoint", "dig", "dashboard", "api", "spec"];
+    const skills = [
+      "handoff",
+      "checkpoint",
+      "dig",
+      "dashboard",
+      "api",
+      "spec",
+      "agent"
+    ];
     if (this.repoIngestionSkill) {
       skills.push("repo");
     }
@@ -1145,6 +1172,24 @@ Examples:
   /spec dev-spec
   /spec update prompt-plan "Initialize repository and tooling"
   /spec validate prompt-plan
+`;
+      case "agent":
+        return `
+/agent research "How does the FTS5 search work?"
+/agent maintain "Fix the deprecation warning in webhook.ts"
+/agent spec-run docs/specs/my-feature.md
+
+Parallel agent skill (Willison patterns) \u2014 spawn isolated Claude agents:
+  research  \u2014 Explore codebase, save findings as a frame (read-only)
+  maintain  \u2014 Low-stakes fix, produces a .patch file
+  spec-run  \u2014 Implement a spec on a branch, validate with lint+test+build
+
+Options:
+  --timeout <ms>  Agent timeout in milliseconds (default: 300000)
+
+Each agent runs in a disposable /tmp workspace (git clone --depth=1).
+Patches: git apply .stackmemory/patches/<file>.patch
+Spec branches: cd /tmp/sm-spec-* && git log --oneline
 `;
       case "linear-run":
         return `