@stackmemoryai/stackmemory 1.2.1 → 1.2.2

package/dist/src/cli/commands/skills.js

@@ -697,6 +697,104 @@ Searched ${result.data.timeRange.from} to ${result.data.timeRange.to}`
       process.exit(1);
     }
   });
+  const agentCmd = skillsCmd.command("agent").description("Spawn parallel Claude agents in isolated workspaces");
+  agentCmd.command("research <question>").description("Explore codebase and save findings as a frame").option("--timeout <ms>", "Agent timeout in milliseconds", "300000").action(async (question, options) => {
+    const spinner = ora("Spawning research agent...").start();
+    try {
+      const { context } = await initializeSkillContext();
+      const { ParallelAgentSkill } = await import("../../skills/parallel-agent-skill.js");
+      const agentSkill = new ParallelAgentSkill(context);
+      const result = await agentSkill.research(question, {
+        timeout: parseInt(options.timeout)
+      });
+      spinner.stop();
+      if (result.success) {
+        console.log(chalk.green("\u2713"), result.message);
+        if (result.data?.findings) {
+          console.log(chalk.cyan("\nFindings:\n"));
+          console.log(result.data.findings);
+        }
+      } else {
+        console.log(chalk.red("\u2717"), result.message);
+      }
+      await context.database.disconnect();
+    } catch (error) {
+      spinner.stop();
+      console.error(chalk.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
+  agentCmd.command("maintain <task>").description("Low-stakes fix, produces a .patch file").option("--timeout <ms>", "Agent timeout in milliseconds", "300000").action(async (task, options) => {
+    const spinner = ora("Spawning maintenance agent...").start();
+    try {
+      const { context } = await initializeSkillContext();
+      const { ParallelAgentSkill } = await import("../../skills/parallel-agent-skill.js");
+      const agentSkill = new ParallelAgentSkill(context);
+      const result = await agentSkill.maintain(task, {
+        timeout: parseInt(options.timeout)
+      });
+      spinner.stop();
+      if (result.success) {
+        console.log(chalk.green("\u2713"), result.message);
+        if (result.data) {
+          console.log(chalk.cyan("\nPatch Details:"));
+          console.log(`  Files changed: ${result.data.filesChanged}`);
+          console.log(`  Additions: +${result.data.additions}`);
+          console.log(`  Deletions: -${result.data.deletions}`);
+          console.log(chalk.yellow(`
+  ${result.action}`));
+        }
+      } else {
+        console.log(chalk.red("\u2717"), result.message);
+      }
+      await context.database.disconnect();
+    } catch (error) {
+      spinner.stop();
+      console.error(chalk.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
+  agentCmd.command("spec-run <specPath>").description("Implement a spec on a branch, validate with lint+test+build").option("--timeout <ms>", "Agent timeout in milliseconds", "300000").action(async (specPath, options) => {
+    const spinner = ora("Spawning spec agent...").start();
+    try {
+      const { context } = await initializeSkillContext();
+      const { ParallelAgentSkill } = await import("../../skills/parallel-agent-skill.js");
+      const agentSkill = new ParallelAgentSkill(context);
+      const result = await agentSkill.specRun(specPath, {
+        timeout: parseInt(options.timeout)
+      });
+      spinner.stop();
+      if (result.success) {
+        console.log(chalk.green("\u2713"), result.message);
+      } else {
+        console.log(chalk.red("\u2717"), result.message);
+      }
+      if (result.data) {
+        console.log(chalk.cyan("\nResults:"));
+        console.log(`  Branch: ${result.data.branch}`);
+        console.log(`  Workspace: ${result.data.workDir}`);
+        const v = result.data.validation;
+        if (v) {
+          console.log(
+            `  Lint: ${v.lint ? chalk.green("pass") : chalk.red("fail")}  Test: ${v.test ? chalk.green("pass") : chalk.red("fail")}  Build: ${v.build ? chalk.green("pass") : chalk.red("fail")}`
+          );
+        }
+        if (result.data.diffStat) {
+          console.log(chalk.gray(`
+${result.data.diffStat}`));
+        }
+        if (result.action) {
+          console.log(chalk.yellow(`
+  ${result.action}`));
+        }
+      }
+      await context.database.disconnect();
+    } catch (error) {
+      spinner.stop();
+      console.error(chalk.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
   skillsCmd.command("help [skill]").description("Show help for a specific skill").action(async (skill) => {
     if (skill) {
       switch (skill) {
@@ -725,6 +823,29 @@ Options:
   --security           Focus on security vulnerabilities
   --performance        Focus on performance issues
   --verbose            Show detailed output
+`);
+          break;
+        case "agent":
+          console.log(`
+agent \u2014 Parallel Agent Skill (Willison Patterns)
+
+Spawn isolated Claude agents in disposable /tmp workspaces.
+
+Subcommands:
+  research <question>     Explore codebase, save findings as a frame
+  maintain <task>         Low-stakes fix, produces a .patch file
+  spec-run <specPath>     Implement spec on branch, validate
+
+Options:
+  --timeout <ms>          Agent timeout (default: 300000)
+
+Examples:
+  stackmemory skills agent research "How does FTS5 search work?"
+  stackmemory skills agent maintain "Fix deprecation warning in webhook.ts"
+  stackmemory skills agent spec-run docs/specs/my-feature.md
+
+Apply patches:  git apply .stackmemory/patches/<file>.patch
+Review specs:   cd /tmp/sm-spec-* && git log --oneline
 `);
           break;
         default:
@@ -752,8 +873,9 @@ Options:
       console.log(
         "  spec       - Generate iterative spec docs (one-pager, dev-spec, prompt-plan, agents)"
       );
+      console.log("  linear-run - Execute Linear tasks via RLM orchestrator");
       console.log(
-        "  linear-run - Execute Linear tasks via RLM orchestrator\n"
+        "  agent      - Spawn parallel agents (research, maintain, spec-run)\n"
       );
       console.log(
         chalk.yellow(

package/dist/src/hooks/graphiti-hooks.js

@@ -20,6 +20,17 @@ class GraphitiHooks {
     emitter.registerHandler("session_start", this.onSessionStart.bind(this));
     emitter.registerHandler("file_change", this.onFileChange.bind(this));
     emitter.registerHandler("session_end", this.onSessionEnd.bind(this));
+    emitter.registerHandler("input_idle", this.onInputIdle.bind(this));
+    emitter.registerHandler("context_switch", this.onContextSwitch.bind(this));
+    emitter.registerHandler("prompt_submit", this.onPromptSubmit.bind(this));
+    emitter.registerHandler("tool_use", this.onToolUse.bind(this));
+    emitter.registerHandler(
+      "suggestion_ready",
+      this.onSuggestionReady.bind(this)
+    );
+    emitter.registerHandler("agent_start", this.onAgentStart.bind(this));
+    emitter.registerHandler("agent_complete", this.onAgentComplete.bind(this));
+    emitter.registerHandler("agent_error", this.onAgentError.bind(this));
     logger.info("Graphiti hooks registered", {
       endpoint: this.config.endpoint,
       backend: this.config.backend,
@@ -82,6 +93,144 @@ class GraphitiHooks {
       });
     }
   }
+  async onInputIdle(event) {
+    const idle = event;
+    try {
+      const episode = {
+        type: "input_idle",
+        content: {
+          idleDuration: idle.data.idleDuration,
+          lastInput: idle.data.lastInput
+        },
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti input_idle episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onContextSwitch(event) {
+    const ctx = event;
+    try {
+      const episode = {
+        type: "context_switch",
+        content: {
+          fromBranch: ctx.data.fromBranch,
+          toBranch: ctx.data.toBranch,
+          fromProject: ctx.data.fromProject,
+          toProject: ctx.data.toProject
+        },
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti context_switch episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onPromptSubmit(event) {
+    try {
+      const episode = {
+        type: "prompt_submit",
+        content: event.data || {},
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti prompt_submit episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onToolUse(event) {
+    try {
+      const episode = {
+        type: "tool_use",
+        content: event.data || {},
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti tool_use episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onSuggestionReady(event) {
+    const suggestion = event;
+    try {
+      const episode = {
+        type: "suggestion_ready",
+        content: {
+          source: suggestion.data.source,
+          confidence: suggestion.data.confidence,
+          preview: suggestion.data.preview
+        },
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti suggestion_ready episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onAgentStart(event) {
+    const e = event;
+    try {
+      const episode = {
+        type: "agent_start",
+        content: { agentType: e.data.agentType, task: e.data.task },
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti agent_start episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onAgentComplete(event) {
+    const e = event;
+    try {
+      const episode = {
+        type: "agent_complete",
+        content: { ...e.data },
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti agent_complete episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async onAgentError(event) {
+    const e = event;
+    try {
+      const episode = {
+        type: "agent_error",
+        content: { agentType: e.data.agentType, error: e.data.error },
+        timestamp: Date.now(),
+        source: "stackmemory"
+      };
+      await this.client.upsertEpisode(episode);
+    } catch (error) {
+      logger.debug("Graphiti agent_error episode failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   // Expose a simple temporal query helper for future MCP tooling
   async buildTemporalContext(query = {}) {
     const now = Date.now();

package/dist/src/hooks/session-summary.js

@@ -3,6 +3,8 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
 import { pickNextLinearTask } from "./linear-task-picker.js";
 function formatDuration(ms) {
   const seconds = Math.floor(ms / 1e3);
@@ -125,6 +127,34 @@ async function generateSuggestions(context) {
     }
   } catch {
   }
+  try {
+    const patchDir = path.join(process.cwd(), ".stackmemory", "patches");
+    if (fs.existsSync(patchDir)) {
+      const patches = fs.readdirSync(patchDir).filter((f) => f.endsWith(".patch"));
+      if (patches.length > 0) {
+        suggestions.push({
+          key: String(keyIndex++),
+          label: `Review ${patches.length} pending patch${patches.length > 1 ? "es" : ""}`,
+          action: `ls -la .stackmemory/patches/`,
+          priority: 75
+        });
+      }
+    }
+  } catch {
+  }
+  try {
+    const tmpEntries = fs.readdirSync("/tmp").filter((d) => d.startsWith("sm-spec-"));
+    if (tmpEntries.length > 0) {
+      const latest = path.join("/tmp", tmpEntries[tmpEntries.length - 1]);
+      suggestions.push({
+        key: String(keyIndex++),
+        label: `Inspect spec branch (${tmpEntries.length} workspace${tmpEntries.length > 1 ? "s" : ""})`,
+        action: `cd ${latest} && git log --oneline -5`,
+        priority: 65
+      });
+    }
+  } catch {
+  }
   const durationMs = Date.now() - context.sessionStartTime;
   if (durationMs > 30 * 60 * 1e3) {
     suggestions.push({

package/dist/src/integrations/graphiti/linear-graphiti-bridge.js

@@ -0,0 +1,115 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { logger } from "../../core/monitoring/logger.js";
+import { GraphitiClient } from "./client.js";
+class LinearGraphitiBridge {
+  client;
+  constructor(config = {}) {
+    this.client = new GraphitiClient(config);
+  }
+  async processWebhook(payload) {
+    const { action, data } = payload;
+    const now = Date.now();
+    try {
+      const episode = {
+        type: `linear_issue_${action}`,
+        content: {
+          identifier: data.identifier,
+          title: data.title,
+          action,
+          state: data.state?.name,
+          priority: data.priority,
+          assignee: data.assignee?.name
+        },
+        timestamp: now,
+        source: "linear"
+      };
+      await this.client.upsertEpisode(episode);
+      if (action === "remove") return;
+      const entities = [
+        {
+          type: "Issue",
+          name: data.identifier,
+          summary: data.title,
+          properties: {
+            linearId: data.id,
+            state: data.state?.name,
+            priority: data.priority
+          }
+        }
+      ];
+      if (data.assignee) {
+        entities.push({
+          type: "Person",
+          name: data.assignee.name,
+          properties: {
+            linearId: data.assignee.id,
+            email: data.assignee.email
+          }
+        });
+      }
+      if (data.team) {
+        entities.push({
+          type: "Team",
+          name: data.team.name,
+          properties: { linearId: data.team.id, key: data.team.key }
+        });
+      }
+      if (data.labels?.length) {
+        for (const label of data.labels) {
+          entities.push({
+            type: "Label",
+            name: label.name,
+            properties: { linearId: label.id, color: label.color }
+          });
+        }
+      }
+      const entityResult = await this.client.upsertEntities(entities);
+      const issueId = entityResult.ids[0];
+      const relations = [];
+      let idx = 1;
+      if (data.assignee) {
+        relations.push({
+          fromId: issueId,
+          toId: entityResult.ids[idx],
+          type: "ASSIGNED_TO",
+          validFrom: now
+        });
+        idx++;
+      }
+      if (data.team) {
+        relations.push({
+          fromId: issueId,
+          toId: entityResult.ids[idx],
+          type: "BELONGS_TO",
+          validFrom: now
+        });
+        idx++;
+      }
+      if (data.labels?.length) {
+        for (let i = 0; i < data.labels.length; i++) {
+          relations.push({
+            fromId: issueId,
+            toId: entityResult.ids[idx + i],
+            type: "HAS_LABEL",
+            validFrom: now
+          });
+        }
+      }
+      if (relations.length > 0) {
+        await this.client.upsertRelations(relations);
+      }
+    } catch (error) {
+      logger.debug("Linear-Graphiti bridge error", {
+        action,
+        identifier: data.identifier,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}
+export {
+  LinearGraphitiBridge
+};

package/dist/src/integrations/greptile/client.js

@@ -0,0 +1,101 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { DEFAULT_GREPTILE_CONFIG } from "./config.js";
+class GreptileClientError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "GreptileClientError";
+  }
+}
+class GreptileClient {
+  config;
+  client = null;
+  transport = null;
+  connecting = null;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_GREPTILE_CONFIG, ...config };
+    if (!this.config.enabled || !this.config.apiKey) {
+      throw new GreptileClientError(
+        "Greptile integration disabled (GREPTILE_API_KEY not set)",
+        "DISABLED"
+      );
+    }
+  }
+  async ensureConnected() {
+    if (this.client) return this.client;
+    if (this.connecting) {
+      await this.connecting;
+      return this.client;
+    }
+    this.connecting = this.connect();
+    try {
+      await this.connecting;
+      return this.client;
+    } finally {
+      this.connecting = null;
+    }
+  }
+  async connect() {
+    const transport = new StreamableHTTPClientTransport(
+      new URL(this.config.mcpEndpoint),
+      {
+        requestInit: {
+          headers: {
+            Authorization: `Bearer ${this.config.apiKey}`
+          }
+        },
+        reconnectionOptions: {
+          maxRetries: this.config.maxRetries,
+          initialReconnectionDelay: 1e3,
+          reconnectionDelayGrowFactor: 1.5,
+          maxReconnectionDelay: 1e4
+        }
+      }
+    );
+    const client = new Client(
+      { name: "stackmemory-greptile", version: "1.0.0" },
+      { capabilities: {} }
+    );
+    transport.onclose = () => {
+      this.client = null;
+      this.transport = null;
+    };
+    await client.connect(transport);
+    this.client = client;
+    this.transport = transport;
+  }
+  async callTool(name, args = {}) {
+    const client = await this.ensureConnected();
+    const result = await client.callTool({ name, arguments: args });
+    if (result.content && Array.isArray(result.content)) {
+      const textParts = result.content.filter(
+        (c) => c.type === "text" && typeof c.text === "string"
+      ).map((c) => c.text);
+      if (textParts.length === 0) return result;
+      const combined = textParts.join("\n");
+      try {
+        return JSON.parse(combined);
+      } catch {
+        return combined;
+      }
+    }
+    return result;
+  }
+  async disconnect() {
+    if (this.transport) {
+      await this.transport.close();
+    }
+    this.client = null;
+    this.transport = null;
+    this.connecting = null;
+  }
+}
+export {
+  GreptileClient,
+  GreptileClientError
+};

package/dist/src/integrations/greptile/config.js

@@ -0,0 +1,14 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const DEFAULT_GREPTILE_CONFIG = {
+  enabled: !!process.env.GREPTILE_API_KEY,
+  mcpEndpoint: process.env.GREPTILE_MCP_ENDPOINT || "https://api.greptile.com/mcp",
+  apiKey: process.env.GREPTILE_API_KEY || "",
+  timeoutMs: 15e3,
+  maxRetries: 2
+};
+export {
+  DEFAULT_GREPTILE_CONFIG
+};

package/dist/src/integrations/greptile/index.js

@@ -0,0 +1,11 @@
+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 "./config.js";
+import { GreptileClient, GreptileClientError } from "./client.js";
+export {
+  DEFAULT_GREPTILE_CONFIG,
+  GreptileClient,
+  GreptileClientError
+};

package/dist/src/integrations/greptile/types.js

@@ -0,0 +1,4 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);

package/dist/src/integrations/linear/webhook.js

@@ -22,6 +22,7 @@ function getOptionalEnv(key) {
 class LinearWebhookHandler {
   syncEngine;
   taskStore;
+  graphitiBridge;
   webhookSecret;
   constructor(webhookSecret) {
     this.webhookSecret = webhookSecret || process.env["LINEAR_WEBHOOK_SECRET"];
@@ -38,6 +39,12 @@ class LinearWebhookHandler {
   setTaskStore(taskStore) {
     this.taskStore = taskStore;
   }
+  /**
+   * Set the Graphiti bridge for knowledge graph sync
+   */
+  setGraphitiBridge(bridge) {
+    this.graphitiBridge = bridge;
+  }
   /**
    * Verify webhook signature
    */
@@ -104,6 +111,15 @@ class LinearWebhookHandler {
       default:
         logger.warn(`Unknown webhook action: ${payload.action}`);
     }
+    if (this.graphitiBridge) {
+      this.graphitiBridge.processWebhook(payload).catch((err) => {
+        logger.debug("Linear-Graphiti bridge error", {
+          action: payload.action,
+          identifier: payload.data.identifier,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+    }
   }
   /**
    * Handle issue created in Linear