@stackmemoryai/stackmemory 1.2.0 → 1.2.2

package/dist/src/cli/claude-sm.js

@@ -35,6 +35,14 @@ import {
   sendCtrlC,
   sessionExists
 } from "../features/workers/tmux-manager.js";
+import {
+  CANONICAL_HOOKS,
+  mergeSettings,
+  hasDeadHooks,
+  readSettings,
+  writeSettingsAtomic,
+  getSettingsPath
+} from "../utils/hook-installer.js";
 const DEFAULT_SM_CONFIG = {
   defaultWorktree: false,
   defaultSandbox: false,
@@ -332,6 +340,62 @@ class ClaudeSM {
     }
     return null;
   }
+  /**
+   * Ensure Claude Code hooks are installed. Copies missing scripts from
+   * templates and updates settings.json. Non-fatal on any error.
+   */
+  ensureHooks() {
+    try {
+      const hooksDir = path.join(os.homedir(), ".claude", "hooks");
+      if (!fs.existsSync(hooksDir)) {
+        fs.mkdirSync(hooksDir, { recursive: true });
+      }
+      const candidateDirs = [
+        path.join(__dirname, "../../templates/claude-hooks"),
+        path.join(__dirname, "../../../templates/claude-hooks"),
+        path.join(
+          __dirname,
+          "..",
+          "..",
+          "..",
+          "..",
+          "templates",
+          "claude-hooks"
+        )
+      ];
+      const templatesDir = candidateDirs.find(
+        (d) => fs.existsSync(d) && fs.readdirSync(d).length > 0
+      );
+      if (!templatesDir) return;
+      let copiedCount = 0;
+      for (const entry of CANONICAL_HOOKS) {
+        const dest = path.join(hooksDir, entry.scriptName);
+        if (!fs.existsSync(dest)) {
+          const src = path.join(templatesDir, entry.scriptName);
+          if (fs.existsSync(src)) {
+            fs.copyFileSync(src, dest);
+            try {
+              fs.chmodSync(dest, 493);
+            } catch {
+            }
+            copiedCount++;
+          }
+        }
+      }
+      const settingsPath = getSettingsPath();
+      const current = readSettings(settingsPath);
+      if (copiedCount > 0 || hasDeadHooks(current)) {
+        const merged = mergeSettings(current, hooksDir);
+        writeSettingsAtomic(merged, settingsPath);
+      }
+      if (copiedCount > 0) {
+        console.log(
+          chalk.gray(`   Hooks: installed ${copiedCount} missing hook(s)`)
+        );
+      }
+    } catch {
+    }
+  }
   loadContext() {
     if (!this.config.contextEnabled) return;
     try {
@@ -554,6 +618,7 @@ Session ended (exit ${exitCode ?? 0})`));
       }
     }
     this.loadContext();
+    this.ensureHooks();
     process.env["CLAUDE_INSTANCE_ID"] = this.config.instanceId;
     if (this.config.worktreePath) {
       process.env["CLAUDE_WORKTREE_PATH"] = this.config.worktreePath;

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