@stackmemoryai/stackmemory 1.2.8 → 1.3.0

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