gitmem-mcp 0.2.0 → 1.0.1

package/bin/gitmem.js

@@ -4,15 +4,30 @@
  * GitMem CLI
  *
  * Commands:
- *   gitmem setup     — Output SQL to paste into Supabase SQL Editor (pro/dev)
- *   gitmem init      — Load starter scars (local JSON or Supabase)
- *   gitmem configure — Generate .mcp.json entry for Claude Code
- *   gitmem server    — Start MCP server (default)
+ *   gitmem init            — Interactive setup wizard (detects, prompts, merges)
+ *   gitmem uninstall       — Clean reverse of everything init did
+ *   gitmem setup           — Output SQL to paste into Supabase SQL Editor (pro/dev)
+ *   gitmem configure       — Generate .mcp.json entry for Claude Code
+ *   gitmem check           — Run diagnostic health check
+ *   gitmem install-hooks   — Install Claude Code hooks plugin
+ *   gitmem uninstall-hooks — Remove Claude Code hooks plugin
+ *   gitmem server          — Start MCP server (default)
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync,
+  cpSync,
+  rmSync,
+  readdirSync,
+  chmodSync,
+  statSync,
+} from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
+import { homedir } from "os";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const command = process.argv[2];
@@ -22,26 +37,32 @@ function printUsage() {
 GitMem — Institutional Memory for AI Coding
 
 Usage:
-  npx gitmem setup      Output SQL for Supabase schema setup (pro/dev tier)
-  npx gitmem init       Load starter scars (auto-detects tier)
-  npx gitmem configure  Generate .mcp.json config for Claude Code
-  npx gitmem server     Start MCP server (default)
-  npx gitmem help       Show this help message
-
-Free Tier (zero config):
-  1. npx gitmem init
-  2. npx gitmem configure
-  3. Copy CLAUDE.md.template into your project
-  4. Start coding — memory is active!
+  npx gitmem init              Interactive setup wizard (recommended)
+  npx gitmem init --yes        Non-interactive setup (accept all defaults)
+  npx gitmem init --dry-run    Show what would be configured
+  npx gitmem uninstall         Clean removal of gitmem from project
+  npx gitmem uninstall --all   Also delete .gitmem/ data directory
+
+Other commands:
+  npx gitmem setup             Output SQL for Supabase schema setup (pro/dev tier)
+  npx gitmem configure         Generate .mcp.json config for Claude Code
+  npx gitmem check             Run diagnostic health check
+  npx gitmem check --full      Full diagnostic with benchmarks
+  npx gitmem install-hooks     Install Claude Code hooks (standalone)
+  npx gitmem uninstall-hooks   Remove Claude Code hooks (standalone)
+  npx gitmem server            Start MCP server (default)
+  npx gitmem help              Show this help message
+
+Quick Start:
+  npx gitmem init              One command sets up everything
+  npx gitmem uninstall         One command removes everything
 
 Pro Tier (with Supabase):
   1. Create free Supabase project → database.new
   2. npx gitmem setup   (copy SQL → Supabase SQL Editor)
-  3. Get API key for embeddings (OpenAI, OpenRouter, or Ollama)
-  4. npx gitmem configure
-  5. npx gitmem init    (load starter scars into Supabase)
-  6. Copy CLAUDE.md.template into your project
-  7. Start coding — memory is active!
+  3. Set SUPABASE_URL + SUPABASE_SERVICE_ROLE_KEY env vars
+  4. npx gitmem init    (auto-detects pro tier)
+  5. Start coding — memory is active!
 `);
 }
 
@@ -64,6 +85,10 @@ async function cmdInit() {
   const supabaseUrl = process.env.SUPABASE_URL;
   const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
 
+  // Parse --project flag
+  const projectIdx = process.argv.indexOf("--project");
+  const projectArg = projectIdx !== -1 ? process.argv[projectIdx + 1] : null;
+
   let starterScars;
   try {
     const scarsPath = join(__dirname, "..", "schema", "starter-scars.json");
@@ -83,6 +108,29 @@ async function cmdInit() {
       mkdirSync(gitmemDir, { recursive: true });
     }
 
+    // Write config.json (with project if specified via --project)
+    const configPath = join(gitmemDir, "config.json");
+    if (!existsSync(configPath)) {
+      const config = {};
+      if (projectArg) config.project = projectArg;
+      writeFileSync(configPath, JSON.stringify(config, null, 2));
+      if (projectArg) {
+        console.log(`  + Created .gitmem/config.json (project: "${projectArg}")`);
+      } else {
+        console.log("  + Created .gitmem/config.json");
+      }
+    } else if (projectArg) {
+      // Config exists — update project field
+      try {
+        const existing = JSON.parse(readFileSync(configPath, "utf-8"));
+        existing.project = projectArg;
+        writeFileSync(configPath, JSON.stringify(existing, null, 2));
+        console.log(`  + Updated .gitmem/config.json project: "${projectArg}"`);
+      } catch {
+        console.warn("  (Could not update config.json)");
+      }
+    }
+
     const learningsPath = join(gitmemDir, "learnings.json");
     let existing = [];
     if (existsSync(learningsPath)) {
@@ -116,6 +164,29 @@ async function cmdInit() {
       }
     }
 
+    // Auto-allow gitmem MCP tools in Claude Code project settings
+    const claudeDir = join(process.cwd(), ".claude");
+    const settingsPath = join(claudeDir, "settings.json");
+    try {
+      let settings = {};
+      if (existsSync(settingsPath)) {
+        settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      } else {
+        mkdirSync(claudeDir, { recursive: true });
+      }
+      const permissions = settings.permissions || {};
+      const allow = permissions.allow || [];
+      const pattern = "mcp__gitmem__*";
+      if (!allow.includes(pattern)) {
+        allow.push(pattern);
+        settings.permissions = { ...permissions, allow };
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        console.log("  + Auto-allowed gitmem tools in .claude/settings.json");
+      }
+    } catch (err) {
+      console.warn("  (Could not update .claude/settings.json — you may need to allow gitmem tools manually)");
+    }
+
     console.log("");
     console.log(`Done: ${added} new scars added to .gitmem/learnings.json`);
     console.log("");
@@ -127,6 +198,23 @@ async function cmdInit() {
     return;
   }
 
+  // Write/update .gitmem/config.json if --project specified
+  if (projectArg) {
+    const gitmemDir = join(process.cwd(), ".gitmem");
+    if (!existsSync(gitmemDir)) {
+      mkdirSync(gitmemDir, { recursive: true });
+    }
+    const configPath = join(gitmemDir, "config.json");
+    let config = {};
+    if (existsSync(configPath)) {
+      try { config = JSON.parse(readFileSync(configPath, "utf-8")); } catch {}
+    }
+    config.project = projectArg;
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log(`  + Set project: "${projectArg}" in .gitmem/config.json`);
+    console.log("");
+  }
+
   // Pro/Dev tier: load into Supabase via REST API
   const tablePrefix = process.env.GITMEM_TABLE_PREFIX || "gitmem_";
   const restUrl = `${supabaseUrl}/rest/v1/${tablePrefix}learnings`;
@@ -164,6 +252,29 @@ async function cmdInit() {
     }
   }
 
+  // Auto-allow gitmem MCP tools in Claude Code project settings
+  const claudeDir = join(process.cwd(), ".claude");
+  const settingsPath = join(claudeDir, "settings.json");
+  try {
+    let settings = {};
+    if (existsSync(settingsPath)) {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    } else {
+      mkdirSync(claudeDir, { recursive: true });
+    }
+    const permissions = settings.permissions || {};
+    const allow = permissions.allow || [];
+    const pattern = "mcp__gitmem__*";
+    if (!allow.includes(pattern)) {
+      allow.push(pattern);
+      settings.permissions = { ...permissions, allow };
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+      console.log("  + Auto-allowed gitmem tools in .claude/settings.json");
+    }
+  } catch (err) {
+    console.warn("  (Could not update .claude/settings.json — you may need to allow gitmem tools manually)");
+  }
+
   console.log("");
   console.log(`Done: ${loaded} loaded, ${failed} failed`);
 
@@ -183,7 +294,7 @@ function cmdConfigure() {
       mcpServers: {
         gitmem: {
           command: "npx",
-          args: ["-y", "@nteg-dev/gitmem"],
+          args: ["-y", "gitmem-mcp"],
         },
       },
     };
@@ -202,7 +313,7 @@ function cmdConfigure() {
       mcpServers: {
         gitmem: {
           command: "npx",
-          args: ["-y", "@nteg-dev/gitmem"],
+          args: ["-y", "gitmem-mcp"],
           env: {
             SUPABASE_URL: "https://YOUR_PROJECT.supabase.co",
             SUPABASE_SERVICE_ROLE_KEY: "eyJ...",
@@ -238,7 +349,7 @@ function cmdConfigure() {
  */
 async function cmdSessionStart() {
   const args = process.argv.slice(3);
-  let project = "orchestra_dev";
+  let project = undefined;
   let agentIdentity = undefined;
 
   for (let i = 0; i < args.length; i++) {
@@ -347,16 +458,257 @@ async function cmdSessionRefresh() {
   }
 }
 
+/**
+ * Install gitmem hooks as project-level hooks in .claude/settings.json
+ *
+ * Writes hook entries pointing to scripts in node_modules/gitmem-mcp/hooks/scripts/.
+ * No plugin registration needed — Claude Code reads hooks directly from settings.
+ * Use --force to overwrite existing hook entries.
+ */
+function cmdInstallHooks() {
+  const force = process.argv.includes("--force");
+  const scriptsDir = join(__dirname, "..", "hooks", "scripts");
+  const claudeDir = join(process.cwd(), ".claude");
+  const settingsPath = join(claudeDir, "settings.json");
+
+  console.log("GitMem Hooks — Install");
+  console.log("======================");
+  console.log("");
+
+  // Verify bundled scripts exist
+  if (!existsSync(scriptsDir) || !existsSync(join(scriptsDir, "session-start.sh"))) {
+    console.error("Error: Hook scripts not found at:", scriptsDir);
+    console.error("Ensure gitmem-mcp is installed correctly.");
+    process.exit(1);
+  }
+
+  // Make scripts executable
+  for (const file of readdirSync(scriptsDir)) {
+    if (file.endsWith(".sh")) {
+      chmodSync(join(scriptsDir, file), 0o755);
+    }
+  }
+
+  // Build hook entries using node_modules path (resolved from CWD)
+  const relScripts = "node_modules/gitmem-mcp/hooks/scripts";
+  const gitmemHooks = {
+    SessionStart: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `bash ${relScripts}/session-start.sh`,
+            statusMessage: "Initializing GitMem session...",
+            timeout: 5000,
+          },
+        ],
+      },
+    ],
+    PreToolUse: [
+      { matcher: "Bash", hooks: [{ type: "command", command: `bash ${relScripts}/recall-check.sh`, timeout: 5000 }] },
+      { matcher: "Write", hooks: [{ type: "command", command: `bash ${relScripts}/recall-check.sh`, timeout: 5000 }] },
+      { matcher: "Edit", hooks: [{ type: "command", command: `bash ${relScripts}/recall-check.sh`, timeout: 5000 }] },
+    ],
+    PostToolUse: [
+      { matcher: "mcp__gitmem__recall", hooks: [{ type: "command", command: `bash ${relScripts}/post-tool-use.sh`, timeout: 3000 }] },
+      { matcher: "mcp__gitmem__search", hooks: [{ type: "command", command: `bash ${relScripts}/post-tool-use.sh`, timeout: 3000 }] },
+      { matcher: "Bash", hooks: [{ type: "command", command: `bash ${relScripts}/post-tool-use.sh`, timeout: 3000 }] },
+      { matcher: "Write", hooks: [{ type: "command", command: `bash ${relScripts}/post-tool-use.sh`, timeout: 3000 }] },
+      { matcher: "Edit", hooks: [{ type: "command", command: `bash ${relScripts}/post-tool-use.sh`, timeout: 3000 }] },
+    ],
+    Stop: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `bash ${relScripts}/session-close-check.sh`,
+            timeout: 5000,
+          },
+        ],
+      },
+    ],
+  };
+
+  // Read existing settings or create new
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    } catch {
+      console.warn("  Warning: Could not parse existing .claude/settings.json, creating fresh");
+    }
+  } else {
+    mkdirSync(claudeDir, { recursive: true });
+  }
+
+  // Check if hooks already exist
+  if (settings.hooks && !force) {
+    const hasGitmem = JSON.stringify(settings.hooks).includes("gitmem");
+    if (hasGitmem) {
+      console.log("GitMem hooks already installed in .claude/settings.json");
+      console.log("");
+      console.log("To reinstall (overwrite), run:");
+      console.log("  npx gitmem install-hooks --force");
+      return;
+    }
+  }
+
+  // Merge hooks into settings (replace hooks section entirely)
+  settings.hooks = gitmemHooks;
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+
+  console.log("Hooks written to .claude/settings.json");
+  console.log(`Scripts at: ${relScripts}/`);
+  console.log("");
+
+  // Verify gitmem MCP is configured
+  let mcpFound = false;
+  const mcpPaths = [
+    join(process.cwd(), ".mcp.json"),
+    join(process.cwd(), ".claude", "mcp.json"),
+    join(homedir(), ".claude.json"),
+  ];
+  for (const p of mcpPaths) {
+    if (existsSync(p)) {
+      try {
+        const cfg = JSON.parse(readFileSync(p, "utf-8"));
+        const servers = cfg.mcpServers || {};
+        if (servers.gitmem || servers["gitmem-mcp"]) {
+          mcpFound = true;
+          break;
+        }
+      } catch {
+        // ignore parse errors
+      }
+    }
+  }
+
+  if (!mcpFound) {
+    console.log("WARNING: gitmem MCP server not detected in .mcp.json.");
+    console.log("  Hooks will be silent until gitmem MCP is configured.");
+    console.log("  Run: npx gitmem configure");
+    console.log("");
+  }
+
+  console.log("Installed! Hooks will activate on next Claude Code session.");
+  console.log("");
+  console.log("To update after a gitmem version bump:");
+  console.log("  npx gitmem install-hooks --force");
+}
+
+/**
+ * Uninstall gitmem hooks from .claude/settings.json
+ *
+ * Removes the hooks section, cleans up legacy plugin directories,
+ * and removes temp state directories.
+ */
+function cmdUninstallHooks() {
+  console.log("GitMem Hooks — Uninstall");
+  console.log("========================");
+  console.log("");
+
+  // Remove hooks from .claude/settings.json
+  const settingsPath = join(process.cwd(), ".claude", "settings.json");
+  if (existsSync(settingsPath)) {
+    try {
+      const cfg = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      if (cfg.hooks) {
+        delete cfg.hooks;
+        writeFileSync(settingsPath, JSON.stringify(cfg, null, 2));
+        console.log("[uninstall] Removed hooks from .claude/settings.json");
+      } else {
+        console.log("[uninstall] No hooks found in .claude/settings.json");
+      }
+      // Also clean legacy enabledPlugins
+      if (cfg.enabledPlugins) {
+        for (const key of Object.keys(cfg.enabledPlugins)) {
+          if (key.startsWith("gitmem-hooks")) {
+            delete cfg.enabledPlugins[key];
+            writeFileSync(settingsPath, JSON.stringify(cfg, null, 2));
+            console.log("[cleanup] Removed legacy enabledPlugins entry");
+          }
+        }
+      }
+    } catch {
+      // ignore parse errors
+    }
+  }
+
+  // Clean legacy plugin directory (from old install-hooks)
+  const pluginDir = join(homedir(), ".claude", "plugins", "gitmem-hooks");
+  if (existsSync(pluginDir)) {
+    rmSync(pluginDir, { recursive: true, force: true });
+    console.log("[cleanup] Removed legacy plugin directory:", pluginDir);
+  }
+
+  // Clean temp state directories
+  let cleaned = 0;
+  try {
+    const tmpDir = "/tmp";
+    for (const entry of readdirSync(tmpDir)) {
+      if (entry.startsWith("gitmem-hooks-")) {
+        const fullPath = join(tmpDir, entry);
+        try {
+          if (statSync(fullPath).isDirectory()) {
+            rmSync(fullPath, { recursive: true, force: true });
+            cleaned++;
+          }
+        } catch {
+          // ignore permission errors on other users' temp dirs
+        }
+      }
+    }
+  } catch {
+    // /tmp read error — not critical
+  }
+
+  if (cleaned > 0) {
+    console.log(`[cleanup] Removed ${cleaned} temp state director(ies) from /tmp/`);
+  }
+
+  // Clean debug log
+  const debugLog = "/tmp/gitmem-hooks-plugin-debug.log";
+  if (existsSync(debugLog)) {
+    rmSync(debugLog, { force: true });
+    console.log("[cleanup] Removed debug log");
+  }
+
+  console.log("");
+  console.log("Uninstall complete.");
+  console.log("");
+  console.log("Notes:");
+  console.log("  - gitmem MCP server config (.mcp.json) was NOT modified");
+  console.log("  - Restart Claude Code for changes to take effect");
+  console.log("  - To reinstall: npx gitmem install-hooks");
+}
+
 switch (command) {
   case "setup":
     cmdSetup();
     break;
   case "init":
+    // New interactive wizard (replaces old cmdInit for CLI usage)
+    import("./init-wizard.js");
+    break;
+  case "uninstall":
+    import("./uninstall.js");
+    break;
+  case "init-scars":
+    // Legacy: load starter scars only (old init behavior)
     cmdInit();
     break;
   case "configure":
     cmdConfigure();
     break;
+  case "check":
+    import("../dist/commands/check.js").then((m) => m.main(process.argv.slice(3)));
+    break;
+  case "install-hooks":
+    cmdInstallHooks();
+    break;
+  case "uninstall-hooks":
+    cmdUninstallHooks();
+    break;
   case "session-start":
     cmdSessionStart();
     break;
@@ -373,7 +725,7 @@ switch (command) {
     printUsage();
     break;
   case undefined:
-    // Default: start MCP server (npx @nteg-dev/gitmem should start serving)
+    // Default: start MCP server (npx gitmem-mcp should start serving)
     import("../dist/index.js");
     break;
   default: