@stackmemoryai/stackmemory 1.2.8 → 1.2.9

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

@@ -4,14 +4,20 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { Command } from "commander";
 import chalk from "chalk";
-import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync } from "fs";
+import {
+  existsSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+  mkdirSync,
+  rmSync
+} from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import { execSync } from "child_process";
 const CLAUDE_DIR = join(homedir(), ".claude");
 const CLAUDE_CONFIG_FILE = join(CLAUDE_DIR, "config.json");
 const MCP_CONFIG_FILE = join(CLAUDE_DIR, "stackmemory-mcp.json");
-const HOOKS_JSON = join(CLAUDE_DIR, "hooks.json");
 function createSetupMCPCommand() {
   return new Command("setup-mcp").description("Auto-configure Claude Code MCP integration").option("--dry-run", "Show what would be configured without making changes").option("--reset", "Reset MCP configuration to defaults").action(async (options) => {
     console.log(chalk.cyan("\nStackMemory MCP Setup\n"));
@@ -199,56 +205,369 @@ function createDoctorCommand() {
         fix: "Run: stackmemory setup-mcp"
       });
     }
-    if (existsSync(HOOKS_JSON)) {
+    {
+      const settingsFile = join(homedir(), ".claude", "settings.json");
+      let hookCount = 0;
+      if (existsSync(settingsFile)) {
+        try {
+          const settings = JSON.parse(readFileSync(settingsFile, "utf8"));
+          if (settings.hooks) {
+            for (const groups of Object.values(settings.hooks)) {
+              for (const group of groups) {
+                hookCount += group.hooks.length;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      if (hookCount > 0) {
+        results.push({
+          name: "Claude Hooks",
+          status: "ok",
+          message: `${hookCount} hooks registered in settings.json`
+        });
+      } else {
+        results.push({
+          name: "Claude Hooks",
+          status: "warn",
+          message: "No hooks registered in settings.json",
+          fix: "Run: stackmemory hooks install"
+        });
+      }
+    }
+    try {
+      const { MCPToolDefinitions } = await import("../../integrations/mcp/tool-definitions.js");
+      const toolDefs = new MCPToolDefinitions();
+      const allTools = toolDefs.getAllToolDefinitions();
+      const toolNames = allTools.map((t) => t.name);
+      const expectedTools = [
+        "sm_digest",
+        "cord_spawn",
+        "team_search",
+        "get_context",
+        "create_task"
+      ];
+      const missing = expectedTools.filter((t) => !toolNames.includes(t));
+      if (missing.length === 0) {
+        results.push({
+          name: "MCP Tools",
+          status: "ok",
+          message: `${allTools.length} tool definitions loaded`
+        });
+      } else {
+        results.push({
+          name: "MCP Tools",
+          status: "warn",
+          message: `${allTools.length} tools loaded, missing: ${missing.join(", ")}`
+        });
+      }
+    } catch (error) {
+      results.push({
+        name: "MCP Tools",
+        status: "error",
+        message: `Failed to load tool definitions: ${error.message}`
+      });
+    }
+    {
+      let linearTokenFound = false;
+      let linearTokenSource = "";
+      if (process.env["LINEAR_API_KEY"]) {
+        linearTokenFound = true;
+        linearTokenSource = "process.env";
+      }
+      if (!linearTokenFound) {
+        const envPath = join(process.cwd(), ".env");
+        if (existsSync(envPath)) {
+          try {
+            const envContent = readFileSync(envPath, "utf8");
+            if (/^LINEAR_API_KEY\s*=/m.test(envContent)) {
+              linearTokenFound = true;
+              linearTokenSource = ".env";
+            }
+          } catch {
+          }
+        }
+      }
+      if (!linearTokenFound) {
+        const envLocalPath = join(process.cwd(), ".env.local");
+        if (existsSync(envLocalPath)) {
+          try {
+            const envContent = readFileSync(envLocalPath, "utf8");
+            if (/^LINEAR_API_KEY\s*=/m.test(envContent)) {
+              linearTokenFound = true;
+              linearTokenSource = ".env.local";
+            }
+          } catch {
+          }
+        }
+      }
+      if (linearTokenFound) {
+        results.push({
+          name: "Linear API Token",
+          status: "ok",
+          message: `Token found via ${linearTokenSource}`
+        });
+      } else {
+        results.push({
+          name: "Linear API Token",
+          status: "warn",
+          message: "LINEAR_API_KEY not found (checked process.env, .env, .env.local)",
+          fix: "Add LINEAR_API_KEY=lin_api_... to your .env file"
+        });
+      }
+    }
+    {
+      const settingsPath = join(homedir(), ".claude", "settings.json");
+      const projectHooksDir = join(process.cwd(), ".claude", "hooks");
+      const globalHooksDir = join(homedir(), ".claude", "hooks");
+      const expectedHookScripts = [
+        "session-rescue.sh",
+        "stop-checkpoint.js",
+        "chime-on-stop.sh",
+        "auto-checkpoint.js",
+        "cord-trace.js"
+      ];
+      const registeredHooks = [];
+      if (existsSync(settingsPath)) {
+        try {
+          const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+          if (settings.hooks) {
+            for (const eventType of Object.keys(settings.hooks)) {
+              const groups = settings.hooks[eventType];
+              for (const group of groups) {
+                for (const hook of group.hooks) {
+                  registeredHooks.push(hook.command);
+                }
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      const presentScripts = [];
+      const missingScripts = [];
+      for (const script of expectedHookScripts) {
+        const inGlobal = existsSync(join(globalHooksDir, script));
+        const inProject = existsSync(join(projectHooksDir, script));
+        if (inGlobal || inProject) {
+          presentScripts.push(script);
+        } else {
+          missingScripts.push(script);
+        }
+      }
+      const unregisteredScripts = expectedHookScripts.filter(
+        (script) => !registeredHooks.some((cmd) => cmd.includes(script))
+      );
+      if (presentScripts.length === expectedHookScripts.length && unregisteredScripts.length === 0) {
+        results.push({
+          name: "Hook Scripts",
+          status: "ok",
+          message: `All ${expectedHookScripts.length} hook scripts present and registered`
+        });
+      } else if (presentScripts.length > 0) {
+        const parts = [];
+        if (missingScripts.length > 0) {
+          parts.push(`missing files: ${missingScripts.join(", ")}`);
+        }
+        if (unregisteredScripts.length > 0) {
+          parts.push(
+            `not in settings.json: ${unregisteredScripts.join(", ")}`
+          );
+        }
+        results.push({
+          name: "Hook Scripts",
+          status: "warn",
+          message: `${presentScripts.length}/${expectedHookScripts.length} hooks present; ${parts.join("; ")}`,
+          fix: "Run: stackmemory hooks install"
+        });
+      } else {
+        results.push({
+          name: "Hook Scripts",
+          status: "warn",
+          message: "No StackMemory hook scripts found",
+          fix: "Run: stackmemory hooks install"
+        });
+      }
+    }
+    {
+      const nodeVersion = process.version;
+      const major = parseInt(nodeVersion.slice(1), 10);
+      if (major >= 20) {
+        results.push({
+          name: "Node.js Version",
+          status: "ok",
+          message: `${nodeVersion} (requires >= 20.0.0)`
+        });
+      } else {
+        results.push({
+          name: "Node.js Version",
+          status: "error",
+          message: `${nodeVersion} is too old (requires >= 20.0.0)`,
+          fix: "Upgrade Node.js: https://nodejs.org/"
+        });
+      }
+    }
+    {
       try {
-        const hooks = JSON.parse(readFileSync(HOOKS_JSON, "utf8"));
-        const hasTraceHook = !!hooks["tool-use-approval"];
-        if (hasTraceHook) {
+        const npmVersion = execSync("npm --version", {
+          encoding: "utf-8",
+          timeout: 5e3
+        }).trim();
+        const npmMajor = parseInt(npmVersion.split(".")[0], 10);
+        if (npmMajor >= 10) {
           results.push({
-            name: "Claude Hooks",
+            name: "npm Version",
             status: "ok",
-            message: "Tool tracing hook installed"
+            message: `v${npmVersion} (requires >= 10.0.0)`
           });
         } else {
           results.push({
-            name: "Claude Hooks",
+            name: "npm Version",
             status: "warn",
-            message: "Hooks file exists but tracing not configured",
-            fix: "Run: stackmemory hooks install"
+            message: `v${npmVersion} is below recommended >= 10.0.0`,
+            fix: "Upgrade npm: npm install -g npm@latest"
           });
         }
       } catch {
         results.push({
-          name: "Claude Hooks",
+          name: "npm Version",
           status: "warn",
-          message: "Could not read hooks.json"
+          message: "Could not detect npm version",
+          fix: "Ensure npm is installed and in PATH"
         });
       }
-    } else {
-      results.push({
-        name: "Claude Hooks",
-        status: "warn",
-        message: "Claude hooks not installed (optional)",
-        fix: "Run: stackmemory hooks install"
-      });
     }
-    const envChecks = [
-      { key: "LINEAR_API_KEY", name: "Linear API Key", optional: true }
-    ];
-    for (const check of envChecks) {
-      const value = process.env[check.key];
-      if (value) {
+    {
+      const configJsonPath = join(homedir(), ".claude", "config.json");
+      const mcpJsonPath = join(homedir(), ".claude", "stackmemory-mcp.json");
+      let mcpRegistered = false;
+      let mcpServerConfigured = false;
+      if (existsSync(configJsonPath)) {
+        try {
+          const configJson = JSON.parse(readFileSync(configJsonPath, "utf8"));
+          const configFiles = configJson?.mcp?.configFiles || [];
+          mcpRegistered = configFiles.some(
+            (f) => f.includes("stackmemory")
+          );
+        } catch {
+        }
+      }
+      if (existsSync(mcpJsonPath)) {
+        try {
+          const mcpConfig = JSON.parse(readFileSync(mcpJsonPath, "utf8"));
+          mcpServerConfigured = !!mcpConfig?.mcpServers?.stackmemory;
+        } catch {
+        }
+      }
+      if (mcpRegistered && mcpServerConfigured) {
         results.push({
-          name: check.name,
+          name: "MCP Registration",
           status: "ok",
-          message: "Environment variable set"
+          message: "StackMemory MCP registered in Claude config.json and server configured"
         });
-      } else if (!check.optional) {
+      } else if (mcpServerConfigured && !mcpRegistered) {
         results.push({
-          name: check.name,
-          status: "error",
-          message: "Required environment variable not set",
-          fix: `Set ${check.key} in your .env file`
+          name: "MCP Registration",
+          status: "warn",
+          message: "MCP server config exists but not referenced in config.json",
+          fix: "Run: stackmemory setup-mcp"
+        });
+      } else if (mcpRegistered && !mcpServerConfigured) {
+        results.push({
+          name: "MCP Registration",
+          status: "warn",
+          message: "config.json references MCP but server config missing",
+          fix: "Run: stackmemory setup-mcp"
+        });
+      } else {
+        results.push({
+          name: "MCP Registration",
+          status: "warn",
+          message: "StackMemory not registered in Claude MCP settings",
+          fix: "Run: stackmemory setup-mcp"
+        });
+      }
+    }
+    {
+      const desireDir = join(homedir(), ".stackmemory", "desire-paths");
+      if (existsSync(desireDir)) {
+        try {
+          const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+          const files = readdirSync(desireDir).filter(
+            (f) => f.startsWith("desire-") && f.endsWith(".jsonl")
+          );
+          let totalFailures = 0;
+          let unknownTools = 0;
+          for (const file of files) {
+            const lines = readFileSync(join(desireDir, file), "utf-8").split("\n").filter(Boolean);
+            for (const line of lines) {
+              try {
+                const entry = JSON.parse(line);
+                if (new Date(entry.ts).getTime() < cutoff) continue;
+                totalFailures++;
+                if (entry.category === "unknown_tool") unknownTools++;
+              } catch {
+              }
+            }
+          }
+          if (totalFailures > 0) {
+            results.push({
+              name: "Desire Paths",
+              status: unknownTools > 0 ? "warn" : "ok",
+              message: `${totalFailures} tool failures in last 7d (${unknownTools} unknown tools)`,
+              fix: unknownTools > 0 ? "Run: stackmemory desires summary" : void 0
+            });
+          } else {
+            results.push({
+              name: "Desire Paths",
+              status: "ok",
+              message: "No tool failures in last 7d"
+            });
+          }
+        } catch {
+          results.push({
+            name: "Desire Paths",
+            status: "ok",
+            message: "Desire path logging active (no data yet)"
+          });
+        }
+      } else {
+        results.push({
+          name: "Desire Paths",
+          status: "ok",
+          message: "Desire path logging not yet active"
+        });
+      }
+    }
+    {
+      try {
+        const { readDaemonStatus } = await import("../../daemon/daemon-config.js");
+        const status = readDaemonStatus();
+        if (status.running) {
+          const uptime = status.startedAt ? Math.round((Date.now() - status.startedAt) / 1e3 / 60) : 0;
+          const svcCount = Object.values(status.services || {}).filter(
+            (s) => s.enabled
+          ).length;
+          results.push({
+            name: "Background Daemon",
+            status: "ok",
+            message: `Running (PID: ${status.pid}, ${svcCount} services, ${uptime}min uptime)`
+          });
+        } else {
+          results.push({
+            name: "Background Daemon",
+            status: "warn",
+            message: "Daemon not running \u2014 context auto-save and maintenance disabled",
+            fix: "Run: stackmemory daemon start"
+          });
+        }
+      } catch {
+        results.push({
+          name: "Background Daemon",
+          status: "warn",
+          message: "Could not check daemon status",
+          fix: "Run: stackmemory daemon start"
         });
       }
     }
@@ -282,12 +601,23 @@ function createDoctorCommand() {
       if (result.fix) {
         console.log(chalk.cyan(`    Fix: ${result.fix}`));
         if (options.fix && result.status !== "ok") {
-          if (result.fix.includes("stackmemory setup-mcp")) {
-            console.log(chalk.gray("    Attempting auto-fix..."));
-            try {
-              execSync("stackmemory setup-mcp", { stdio: "inherit" });
-            } catch {
-              console.log(chalk.red("    Auto-fix failed"));
+          const fixCmds = [
+            "stackmemory setup-mcp",
+            "stackmemory hooks install",
+            "stackmemory daemon start"
+          ];
+          for (const cmd of fixCmds) {
+            if (result.fix.includes(cmd)) {
+              console.log(chalk.gray(`    Attempting: ${cmd}...`));
+              try {
+                execSync(cmd, {
+                  stdio: "inherit",
+                  timeout: 15e3
+                });
+              } catch {
+                console.log(chalk.red("    Auto-fix failed"));
+              }
+              break;
             }
           }
         }

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

@@ -0,0 +1,168 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Command } from "commander";
+import Database from "better-sqlite3";
+import { join } from "path";
+import { existsSync } from "fs";
+import { v4 as uuidv4 } from "uuid";
+import { FrameManager } from "../../core/context/index.js";
+const VALID_TYPES = [
+  "FACT",
+  "DECISION",
+  "CONSTRAINT",
+  "INTERFACE_CONTRACT",
+  "TODO",
+  "RISK"
+];
+const MAX_CONTENT_LENGTH = 2e3;
+function findProjectRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 20; i++) {
+    if (existsSync(join(dir, ".stackmemory", "context.db"))) {
+      return dir;
+    }
+    const parent = join(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function createTeamCommands() {
+  const team = new Command("team").description(
+    "Team shared context (cross-agent memory)"
+  );
+  team.command("share").description("Share context with other agents (creates shared anchor)").requiredOption("-c, --content <text>", "Anchor text to share").option(
+    "-t, --type <type>",
+    "Anchor type (FACT|DECISION|CONSTRAINT|TODO|RISK)",
+    "FACT"
+  ).option("-p, --priority <n>", "Priority 1-10", "7").option(
+    "--source <src>",
+    "Origin: subagent|teammate-idle|task-complete|manual",
+    "manual"
+  ).option("--agent-id <id>", "Source agent ID").option("--task-id <id>", "Source task ID").action(async (options) => {
+    const projectRoot = findProjectRoot(process.cwd());
+    if (!projectRoot) {
+      console.error(
+        'StackMemory not initialized. Run "stackmemory init" first.'
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const dbPath = join(projectRoot, ".stackmemory", "context.db");
+    const db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    try {
+      let projectId = "default";
+      try {
+        const row = db.prepare(`SELECT value FROM metadata WHERE key = 'project_id'`).get();
+        if (row?.value) projectId = row.value;
+      } catch {
+      }
+      const frameManager = new FrameManager(db, projectId, {
+        skipContextBridge: true
+      });
+      let frameId = frameManager.getCurrentFrameId();
+      if (!frameId) {
+        frameId = frameManager.createFrame({
+          type: "tool_scope",
+          name: "team_share"
+        });
+      }
+      const type = options.type.toUpperCase();
+      if (!VALID_TYPES.includes(type)) {
+        console.error(
+          `Invalid type "${type}". Must be one of: ${VALID_TYPES.join(", ")}`
+        );
+        process.exitCode = 1;
+        return;
+      }
+      const content = options.content.slice(0, MAX_CONTENT_LENGTH);
+      const priority = Math.max(1, Math.min(10, parseInt(options.priority)));
+      const runId = process.env["CLAUDE_INSTANCE_ID"] || process.env["STACKMEMORY_RUN_ID"] || uuidv4();
+      const metadata = {
+        shared: true,
+        sharedBy: runId,
+        sharedAt: Date.now(),
+        source: options.source
+      };
+      if (options.agentId) metadata.agentId = options.agentId;
+      if (options.taskId) metadata.taskId = options.taskId;
+      frameManager.addAnchor(type, content, priority, metadata);
+      console.log(
+        `Shared [${type}] (priority ${priority}): ${content.slice(0, 80)}${content.length > 80 ? "..." : ""}`
+      );
+    } catch (error) {
+      console.error("Failed to share context:", error.message);
+      process.exitCode = 1;
+    } finally {
+      db.close();
+    }
+  });
+  team.command("list").description("List recent shared context from all agents").option("-l, --limit <n>", "Max results", "10").option("--since <epoch>", "Filter by timestamp (ms since epoch)").action(async (options) => {
+    const projectRoot = findProjectRoot(process.cwd());
+    if (!projectRoot) {
+      console.error(
+        'StackMemory not initialized. Run "stackmemory init" first.'
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const dbPath = join(projectRoot, ".stackmemory", "context.db");
+    const db = new Database(dbPath);
+    try {
+      let projectId = "default";
+      try {
+        const row = db.prepare(`SELECT value FROM metadata WHERE key = 'project_id'`).get();
+        if (row?.value) projectId = row.value;
+      } catch {
+      }
+      const limit = parseInt(options.limit) || 10;
+      const since = options.since ? parseInt(options.since) : void 0;
+      const params = [projectId];
+      let whereExtra = "";
+      if (since) {
+        whereExtra = " AND a.created_at > ?";
+        params.push(Math.floor(since / 1e3));
+      }
+      params.push(limit);
+      const rows = db.prepare(
+        `SELECT a.*, f.name as frame_name, f.run_id
+             FROM anchors a
+             JOIN frames f ON a.frame_id = f.frame_id
+             WHERE f.project_id = ?
+               AND a.metadata LIKE '%"shared":true%'${whereExtra}
+             ORDER BY a.priority DESC, a.created_at DESC
+             LIMIT ?`
+      ).all(...params);
+      if (rows.length === 0) {
+        console.log("No shared context found.");
+        return;
+      }
+      console.log(`
+Shared Context (${rows.length} anchors):
+`);
+      for (const row of rows) {
+        const meta = JSON.parse(row.metadata || "{}");
+        const date = new Date(row.created_at * 1e3).toLocaleString();
+        const source = meta.source || "unknown";
+        const runSlice = row.run_id?.slice(0, 8) || "?";
+        console.log(
+          `  [${row.type}] p${row.priority} | ${row.text.slice(0, 100)}${row.text.length > 100 ? "..." : ""}`
+        );
+        console.log(`    source: ${source} | run: ${runSlice} | ${date}`);
+      }
+      console.log("");
+    } catch (error) {
+      console.error("Failed to list context:", error.message);
+      process.exitCode = 1;
+    } finally {
+      db.close();
+    }
+  });
+  return team;
+}
+export {
+  createTeamCommands
+};

package/dist/src/cli/index.js

@@ -55,6 +55,8 @@ import { createAuditCommand } from "./commands/audit.js";
 import { createStatsCommand } from "./commands/stats.js";
 import { createBenchCommand } from "./commands/bench.js";
 import { createDigestCommands } from "./commands/digest.js";
+import { createTeamCommands } from "./commands/team.js";
+import { createDesiresCommands } from "./commands/desires.js";
 import chalk from "chalk";
 import * as fs from "fs";
 import * as path from "path";
@@ -503,6 +505,8 @@ program.addCommand(createAuditCommand());
 program.addCommand(createStatsCommand());
 program.addCommand(createBenchCommand());
 program.addCommand(createDigestCommands());
+program.addCommand(createTeamCommands());
+program.addCommand(createDesiresCommands());
 registerSetupCommands(program);
 program.command("mm-spike").description(
   "Run multi-agent planning/implementation spike (planner/implementer/critic)"