claude-setup 1.1.3 → 1.1.4

package/dist/doctor.js

@@ -1,7 +1,7 @@
-import { existsSync, readFileSync } from "fs";
-import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { execSync, spawnSync } from "child_process";
 import { join } from "path";
-import { readManifest } from "./manifest.js";
+import { readManifest, sha256 } from "./manifest.js";
 import { readState } from "./state.js";
 import { detectOS } from "./os.js";
 import { c, statusLine, section } from "./output.js";
@@ -31,12 +31,17 @@ function safeJsonParse(content) {
         return null;
     }
 }
-export async function runDoctor(verbose = false) {
+export async function runDoctor(verbose = false, fix = false, testHooks = false) {
     const os = detectOS();
     const manifest = await readManifest();
     const state = await readState();
-    const counts = { critical: 0, warnings: 0, healthy: 0 };
-    console.log(`${c.bold("claude-setup doctor")} — ${new Date().toISOString().split("T")[0]} | OS: ${os}\n`);
+    const counts = { critical: 0, warnings: 0, healthy: 0, fixed: 0 };
+    console.log(`${c.bold("claude-setup doctor")} — ${new Date().toISOString().split("T")[0]} | OS: ${os}`);
+    if (fix)
+        console.log(`${c.cyan("Auto-fix mode enabled")}`);
+    if (testHooks)
+        console.log(`${c.cyan("Hook testing enabled")}`);
+    console.log("");
     // --- Check 1: Claude Code version ---
     section("Environment");
     const cv = tryExec("claude --version");
@@ -63,8 +68,12 @@ export async function runDoctor(verbose = false) {
         counts.warnings++;
     }
     // --- Check 2b: Out-of-band edit detection ---
+    // BUG 12 FIX: Distinguish expected modifications (from Claude Code sessions triggered
+    // by /stack-init, /stack-add etc.) from truly unexpected external modifications.
     if (lastRun) {
-        const { createHash } = await import("crypto");
+        const lastCommand = lastRun.command;
+        const expectedModCommands = new Set(["init", "add", "sync"]);
+        const isExpectedMod = expectedModCommands.has(lastCommand);
         const oobFiles = [
             { label: "CLAUDE.md", path: join(process.cwd(), "CLAUDE.md"), snapshotKey: "CLAUDE.md" },
             { label: ".mcp.json", path: join(process.cwd(), ".mcp.json"), snapshotKey: ".mcp.json" },
@@ -74,11 +83,33 @@ export async function runDoctor(verbose = false) {
             if (!existsSync(mf.path))
                 continue;
             const content = readFileSync(mf.path, "utf8");
-            const currentHash = createHash("sha256").update(content).digest("hex");
+            const currentHash = sha256(content);
             const snapshotHash = lastRun.snapshot[mf.snapshotKey];
             if (snapshotHash && currentHash !== snapshotHash) {
-                statusLine("⚠️ ", mf.label, c.yellow("modified outside the CLI since last run — run sync to re-snapshot"));
-                counts.warnings++;
+                if (isExpectedMod) {
+                    if (verbose) {
+                        statusLine("✅", mf.label, `modified after ${lastCommand} (expected — Claude Code session)`);
+                        counts.healthy++;
+                    }
+                }
+                else {
+                    statusLine("⚠️ ", mf.label, c.yellow("modified outside the CLI since last run — run sync to re-snapshot"));
+                    counts.warnings++;
+                    if (fix) {
+                        // Auto-fix: re-snapshot the file
+                        lastRun.snapshot[mf.snapshotKey] = currentHash;
+                        statusLine("🔧", mf.label, c.green("re-snapshotted"));
+                        counts.fixed++;
+                    }
+                }
+            }
+        }
+        // Write back updated manifest if fix modified snapshots
+        if (fix && manifest) {
+            const { writeFileSync: wfs } = await import("fs");
+            const manifestPath = join(process.cwd(), ".claude/claude-setup.json");
+            if (existsSync(manifestPath)) {
+                wfs(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
             }
         }
     }
@@ -88,6 +119,7 @@ export async function runDoctor(verbose = false) {
         const mcp = safeJsonParse(state.mcpJson.content);
         if (mcp && typeof mcp.mcpServers === "object" && mcp.mcpServers !== null) {
             const servers = mcp.mcpServers;
+            let mcpModified = false;
             for (const [name, config] of Object.entries(servers)) {
                 const cmd = config.command;
                 if (!cmd) {
@@ -98,10 +130,30 @@ export async function runDoctor(verbose = false) {
                 if (os === "Windows" && cmd === "npx") {
                     statusLine("🔴", name, c.red(`BROKEN: Windows can't execute npx directly — use cmd /c npx`));
                     counts.critical++;
+                    if (fix) {
+                        // Auto-fix: convert to Windows format
+                        const args = config.args ?? [];
+                        config.command = "cmd";
+                        config.args = ["/c", "npx", ...args];
+                        statusLine("🔧", name, c.green("fixed → cmd /c npx"));
+                        counts.fixed++;
+                        mcpModified = true;
+                    }
                 }
                 else if (os !== "Windows" && cmd === "cmd") {
                     statusLine("⚠️ ", name, c.yellow(`UNNECESSARY: cmd wrapper not needed on ${os}`));
                     counts.warnings++;
+                    if (fix) {
+                        // Auto-fix: remove cmd wrapper
+                        const args = config.args ?? [];
+                        if (args[0] === "/c") {
+                            config.command = args[1] ?? "npx";
+                            config.args = args.slice(2);
+                            statusLine("🔧", name, c.green(`fixed → ${config.command}`));
+                            counts.fixed++;
+                            mcpModified = true;
+                        }
+                    }
                 }
                 else {
                     statusLine("✅", name, `valid, OS-format correct (${cmd})`);
@@ -114,6 +166,12 @@ export async function runDoctor(verbose = false) {
                     if (npxIndex >= 0 && args[npxIndex + 1] !== "-y") {
                         statusLine("⚠️ ", name, c.yellow(`npx without -y flag — installs may hang`));
                         counts.warnings++;
+                        if (fix) {
+                            args.splice(npxIndex + 1, 0, "-y");
+                            statusLine("🔧", name, c.green("added -y flag"));
+                            counts.fixed++;
+                            mcpModified = true;
+                        }
                     }
                     // Check for hardcoded connection strings in args
                     for (const arg of args) {
@@ -134,9 +192,14 @@ export async function runDoctor(verbose = false) {
                     counts.warnings++;
                 }
             }
+            // Write back fixed .mcp.json
+            if (fix && mcpModified) {
+                const mcpPath = join(process.cwd(), ".mcp.json");
+                writeFileSync(mcpPath, JSON.stringify(mcp, null, 2), "utf8");
+                statusLine("🔧", ".mcp.json", c.green("saved with fixes"));
+            }
         }
         else if (mcp) {
-            // Check for flat structure (some .mcp.json files use flat keys)
             if (verbose)
                 statusLine("⚠️ ", ".mcp.json", "no mcpServers key found");
         }
@@ -145,66 +208,172 @@ export async function runDoctor(verbose = false) {
         section("MCP servers");
         statusLine("⏭ ", ".mcp.json", "does not exist");
     }
-    // --- Check 4: Hook quoting bugs ---
+    // --- Check 4: Hook format and quoting ---
     if (state.settings.content) {
         section("Hooks");
         const settings = safeJsonParse(state.settings.content);
         if (settings) {
-            const hookCategories = [
+            const ALL_HOOK_EVENTS = [
                 "PreToolUse", "PostToolUse", "PostToolUseFailure",
-                "Stop", "SessionStart"
+                "Stop", "SessionStart", "Notification", "SubagentStart", "SubagentStop",
+                "UserPromptSubmit", "PermissionRequest", "ConfigChange",
+                "InstructionsLoaded", "TaskCompleted", "TeammateIdle",
+                "StopFailure", "SessionEnd", "PreCompact", "PostCompact",
+                "WorktreeCreate", "WorktreeRemove", "Elicitation", "ElicitationResult",
             ];
-            // Bug 6: Check for model override
+            const validHookNames = new Set(ALL_HOOK_EVENTS);
+            const KNOWN_SETTINGS_KEYS = new Set([
+                "permissions", "model", "env", "allowedTools", "hooks",
+                "disableAllHooks", "statusLine", "outputStyle", "attribution",
+                "includeCoAuthoredBy", "includeGitInstructions", "enableAllProjectMcpServers",
+                "enabledMcpjsonServers", "disabledMcpjsonServers", "apiKeyHelper",
+                "companyAnnouncements", "effortLevel", "language", "$schema",
+            ]);
+            let settingsModified = false;
+            // BUG 13 FIX: Model override with auto-fix
             if (settings["model"]) {
-                statusLine("⚠️ ", "MODEL OVERRIDE", c.yellow(`"model": "${settings["model"]}" in settings.json forces this model on every session. Remove it if not intentional.`));
+                statusLine("⚠️ ", "MODEL OVERRIDE", c.yellow(`"model": "${settings["model"]}" forces this model on every session.\n` +
+                    `      Fix: remove the "model" key from .claude/settings.json, or use /model in Claude Code to switch per-session.`));
                 counts.warnings++;
+                if (fix) {
+                    delete settings["model"];
+                    statusLine("🔧", "MODEL OVERRIDE", c.green("removed — model selection is now per-session"));
+                    counts.fixed++;
+                    settingsModified = true;
+                }
             }
-            // Check for invalid hook event names
-            const validHookNames = new Set(hookCategories);
-            for (const key of Object.keys(settings)) {
-                if (key === "permissions" || key === "model" || key === "env" || key === "allowedTools")
-                    continue;
-                if (Array.isArray(settings[key]) && !validHookNames.has(key)) {
-                    statusLine("🔴", `"${key}"`, c.red(`INVALID hook event name. Valid names: ${hookCategories.join(", ")}`));
-                    counts.critical++;
+            // Determine where hooks live — correct format uses "hooks" key
+            const hooksObj = settings["hooks"] ?? null;
+            const hookSource = hooksObj ?? settings;
+            // Check for invalid hook event names (only in flat format)
+            if (!hooksObj) {
+                for (const key of Object.keys(settings)) {
+                    if (KNOWN_SETTINGS_KEYS.has(key))
+                        continue;
+                    if (Array.isArray(settings[key]) && !validHookNames.has(key)) {
+                        statusLine("🔴", `"${key}"`, c.red(`INVALID hook event name. Valid: ${ALL_HOOK_EVENTS.slice(0, 5).join(", ")}... ` +
+                            `See Claude Code hooks documentation.`));
+                        counts.critical++;
+                    }
                 }
             }
+            // Collect hooks for potential testing
+            const hookCommands = [];
             let foundHooks = false;
-            for (const category of hookCategories) {
-                const hooks = settings[category];
-                if (!hooks || !Array.isArray(hooks))
+            for (const category of ALL_HOOK_EVENTS) {
+                const entries = hookSource[category];
+                if (!entries || !Array.isArray(entries))
                     continue;
-                for (const hook of hooks) {
-                    if (typeof hook !== "object" || !hook)
-                        continue;
-                    const h = hook;
-                    const hookCmd = h.command;
-                    const args = h.args;
-                    if (!hookCmd || !args)
+                for (const entry of entries) {
+                    if (typeof entry !== "object" || !entry)
                         continue;
-                    foundHooks = true;
-                    // Check for bash -c quoting bugs
-                    if (hookCmd === "bash" && args[0] === "-c" && args[1]) {
-                        const shellStr = args[1];
-                        const quotingIssue = checkBashQuoting(shellStr);
-                        if (quotingIssue) {
-                            statusLine("🔴", `${category} hook`, c.red(`quoting bug: ${quotingIssue}`));
-                            counts.critical++;
+                    const e = entry;
+                    if (Array.isArray(e.hooks)) {
+                        const matcher = e.matcher ?? "";
+                        // Validate matcher is valid regex
+                        if (matcher) {
+                            try {
+                                new RegExp(matcher);
+                            }
+                            catch {
+                                statusLine("🔴", `${category} matcher`, c.red(`invalid regex: "${matcher}"`));
+                                counts.critical++;
+                            }
                         }
-                        else {
-                            statusLine("✅", `${category} hook`, "quoting clean");
-                            counts.healthy++;
+                        for (const hook of e.hooks) {
+                            if (typeof hook !== "object" || !hook)
+                                continue;
+                            const h = hook;
+                            foundHooks = true;
+                            if (h.type === "command" && typeof h.command === "string") {
+                                const cmd = h.command;
+                                const bashQuoting = checkBashQuoting(cmd);
+                                if (bashQuoting) {
+                                    statusLine("🔴", `${category} hook`, c.red(`quoting bug: ${bashQuoting}`));
+                                    counts.critical++;
+                                }
+                                else {
+                                    statusLine("✅", `${category} hook`, `command: ${cmd.slice(0, 60)}${cmd.length > 60 ? "..." : ""}`);
+                                    counts.healthy++;
+                                }
+                                hookCommands.push({ event: category, matcher, command: cmd });
+                            }
+                            else {
+                                statusLine("✅", `${category} hook`, `type: ${h.type ?? "unknown"}`);
+                                counts.healthy++;
+                            }
                         }
                     }
                     else {
-                        statusLine("✅", `${category} hook`, "valid");
-                        counts.healthy++;
+                        // Legacy flat format
+                        const hookCmd = e.command;
+                        const args = e.args;
+                        if (!hookCmd)
+                            continue;
+                        foundHooks = true;
+                        if (hookCmd === "bash" && args?.[0] === "-c" && args[1]) {
+                            const quotingIssue = checkBashQuoting(args[1]);
+                            if (quotingIssue) {
+                                statusLine("🔴", `${category} hook`, c.red(`quoting bug: ${quotingIssue}`));
+                                counts.critical++;
+                            }
+                            else {
+                                statusLine("✅", `${category} hook`, "quoting clean");
+                                counts.healthy++;
+                            }
+                            hookCommands.push({ event: category, matcher: "", command: args[1] });
+                        }
+                        else {
+                            statusLine("✅", `${category} hook`, "valid");
+                            counts.healthy++;
+                            hookCommands.push({ event: category, matcher: "", command: `${hookCmd} ${(args ?? []).join(" ")}` });
+                        }
                     }
                 }
             }
             if (!foundHooks && verbose) {
                 statusLine("⏭ ", "Hooks", "none configured");
             }
+            // Write back fixed settings.json
+            if (fix && settingsModified) {
+                const settingsPath = join(process.cwd(), ".claude", "settings.json");
+                writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+                statusLine("🔧", "settings.json", c.green("saved with fixes"));
+            }
+            // --- Feature G: Hook testing (--test-hooks) ---
+            if (testHooks && hookCommands.length > 0) {
+                section("Hook testing");
+                console.log(`${c.dim("Running each hook once in sandbox mode...\n")}`);
+                for (const hook of hookCommands) {
+                    const result = testSingleHook(hook.command, os);
+                    const label = `${hook.event}${hook.matcher ? `:${hook.matcher}` : ""}`;
+                    if (result.status === "pass") {
+                        statusLine("✅", label, c.green(`PASS (${result.timeMs}ms) — ${hook.command.slice(0, 50)}`));
+                        counts.healthy++;
+                    }
+                    else if (result.status === "not_found") {
+                        statusLine("🔴", label, c.red(`FAIL — command not found: ${result.tool}\n` +
+                            `      Install ${result.tool} or remove this hook.`));
+                        counts.critical++;
+                    }
+                    else if (result.status === "timeout") {
+                        statusLine("⚠️ ", label, c.yellow(`TIMEOUT (>${result.timeMs}ms) — hook may hang in real sessions\n` +
+                            `      Command: ${hook.command.slice(0, 50)}`));
+                        counts.warnings++;
+                    }
+                    else if (result.status === "error") {
+                        statusLine("⚠️ ", label, c.yellow(`FAIL (exit ${result.exitCode}, ${result.timeMs}ms)\n` +
+                            `      Command: ${hook.command.slice(0, 50)}\n` +
+                            `      ${result.stderr ? `stderr: ${result.stderr.slice(0, 100)}` : ""}`));
+                        counts.warnings++;
+                    }
+                    else if (result.status === "permission") {
+                        statusLine("🔴", label, c.red(`PERMISSION DENIED — ${hook.command.slice(0, 50)}\n` +
+                            `      Check file permissions or access rights.`));
+                        counts.critical++;
+                    }
+                }
+            }
         }
     }
     else if (verbose) {
@@ -266,7 +435,6 @@ export async function runDoctor(verbose = false) {
                 counts.warnings++;
                 continue;
             }
-            // Extract file/dir references from skill content
             const pathRefs = extractPathReferences(content);
             const staleRefs = pathRefs.filter(ref => !existsSync(ref) && !existsSync(join(process.cwd(), ref)));
             if (staleRefs.length) {
@@ -284,7 +452,6 @@ export async function runDoctor(verbose = false) {
         statusLine("⏭ ", "Skills", "none installed");
     }
     // --- Check 8: Files from last run still on disk ---
-    // Filter __digest__ — it's a virtual key, not a real file
     if (lastRun?.filesRead.length && verbose) {
         section("Files from last run");
         const realFiles = lastRun.filesRead.filter(f => f !== "__digest__" && f !== ".env");
@@ -310,8 +477,13 @@ export async function runDoctor(verbose = false) {
     if (counts.warnings > 0)
         console.log(`  ⚠️  ${c.yellow(`${counts.warnings} warning(s)`)} (degraded behavior)`);
     console.log(`  ✅ ${c.green(`${counts.healthy} healthy`)}`);
-    if (counts.critical > 0) {
-        console.log(`\n${c.red("Fix critical issues first.")} Run ${c.cyan("npx claude-setup sync")} after fixing.`);
+    if (counts.fixed > 0)
+        console.log(`  🔧 ${c.cyan(`${counts.fixed} auto-fixed`)}`);
+    if (counts.critical > 0 && !fix) {
+        console.log(`\n${c.red("Fix critical issues first.")} Run ${c.cyan("npx claude-setup doctor --fix")} to auto-fix what's possible.`);
+    }
+    else if (counts.fixed > 0) {
+        console.log(`\n${c.green("✅ Auto-fix applied.")} Run ${c.cyan("npx claude-setup sync")} to re-snapshot.`);
     }
     else {
         console.log(`\n${c.green("✅ Done.")}`);
@@ -330,8 +502,6 @@ function checkStaleness(lastRunDate) {
     return null;
 }
 function checkBashQuoting(shellStr) {
-    // Check for unescaped double quotes inside the command string
-    // The -c "..." outer string must never contain a bare " character
     let inSingleQuote = false;
     let prevChar = "";
     for (let i = 0; i < shellStr.length; i++) {
@@ -339,17 +509,13 @@ function checkBashQuoting(shellStr) {
         if (ch === "'" && prevChar !== "\\") {
             inSingleQuote = !inSingleQuote;
         }
-        // Unescaped double quote inside single-quoted context is a problem
-        // when the outer wrapper is double quotes
         if (ch === '"' && !inSingleQuote && prevChar !== "\\") {
-            // Check for patterns like ["'] which mix quote types
             if (i > 0 && shellStr[i - 1] === "[") {
                 return `mixed quotes in character class at position ${i}: ...${shellStr.slice(Math.max(0, i - 10), i + 10)}...`;
             }
         }
         prevChar = ch;
     }
-    // Check for unmatched brackets in grep patterns
     const bracketCount = (shellStr.match(/\[/g) || []).length;
     const closeBracketCount = (shellStr.match(/\]/g) || []).length;
     if (bracketCount !== closeBracketCount) {
@@ -359,11 +525,93 @@ function checkBashQuoting(shellStr) {
 }
 function extractPathReferences(skillContent) {
     const paths = [];
-    // Match file/directory references in skill content
-    // Look for patterns like src/, lib/, *.ts references
     const pathPatterns = skillContent.matchAll(/(?:^|\s)((?:src|lib|app|cmd|bin|pkg|internal|api|core|test|tests|spec)\/[\w/.\\-]*)/gm);
     for (const m of pathPatterns) {
         paths.push(m[1].trim());
     }
     return paths;
 }
+/**
+ * Test a single hook command by spawning it.
+ * Checks: command existence, execution, exit code, stderr, timeout.
+ */
+function testSingleHook(command, os) {
+    const TIMEOUT_MS = 10_000;
+    // Extract the base tool from the command
+    const tool = extractToolName(command);
+    // Step 1: Check if the tool exists on the system
+    if (tool) {
+        const whichCmd = os === "Windows" ? `where ${tool} 2>nul` : `which ${tool} 2>/dev/null`;
+        const found = tryExec(whichCmd);
+        if (!found || !found.trim()) {
+            return { status: "not_found", timeMs: 0, tool };
+        }
+    }
+    // Step 2: Actually execute the hook command with a timeout
+    const start = Date.now();
+    try {
+        let result;
+        if (os === "Windows") {
+            result = spawnSync("cmd", ["/c", command], {
+                timeout: TIMEOUT_MS,
+                encoding: "utf8",
+                stdio: ["pipe", "pipe", "pipe"],
+                cwd: process.cwd(),
+            });
+        }
+        else {
+            result = spawnSync("bash", ["-c", command], {
+                timeout: TIMEOUT_MS,
+                encoding: "utf8",
+                stdio: ["pipe", "pipe", "pipe"],
+                cwd: process.cwd(),
+            });
+        }
+        const timeMs = Date.now() - start;
+        if (result.error) {
+            const err = result.error;
+            if (err.code === "ETIMEDOUT") {
+                return { status: "timeout", timeMs: TIMEOUT_MS };
+            }
+            if (err.code === "EACCES" || err.code === "EPERM") {
+                return { status: "permission", timeMs };
+            }
+            return { status: "error", exitCode: -1, stderr: err.message, timeMs };
+        }
+        if (result.status === 0) {
+            return { status: "pass", exitCode: 0, timeMs };
+        }
+        return {
+            status: "error",
+            exitCode: result.status ?? -1,
+            stderr: result.stderr?.trim().slice(0, 200) ?? "",
+            timeMs,
+        };
+    }
+    catch (err) {
+        const timeMs = Date.now() - start;
+        return { status: "error", exitCode: -1, stderr: String(err).slice(0, 200), timeMs };
+    }
+}
+/**
+ * Extract the base tool name from a shell command.
+ * "command -v mvn && mvn compile -q" → "mvn"
+ * "npm run build" → "npm"
+ * "prettier --check ." → "prettier"
+ */
+function extractToolName(command) {
+    // Handle "command -v X && ..." or "which X && ..."
+    const guardMatch = command.match(/(?:command -v|which|where)\s+(\S+)\s*&&\s*(.*)/);
+    if (guardMatch) {
+        return guardMatch[1];
+    }
+    // Handle simple commands
+    const parts = command.trim().split(/\s+/);
+    const first = parts[0];
+    if (!first)
+        return null;
+    // Skip shell builtins
+    if (["cd", "echo", "test", "[", "if", "for", "while"].includes(first))
+        return null;
+    return first;
+}

package/dist/index.js

@@ -7,6 +7,9 @@ import { runSync } from "./commands/sync.js";
 import { runStatus } from "./commands/status.js";
 import { runDoctorCommand } from "./commands/doctor.js";
 import { runRemove } from "./commands/remove.js";
+import { runRestore } from "./commands/restore.js";
+import { runCompare } from "./commands/compare.js";
+import { runExport } from "./commands/export.js";
 const require = createRequire(import.meta.url);
 const pkg = require("../package.json");
 const program = new Command();
@@ -18,7 +21,8 @@ program
     .command("init")
     .description("Full project setup — new or existing")
     .option("--dry-run", "Preview what would be written without writing")
-    .action((opts) => runInit({ dryRun: opts.dryRun }));
+    .option("--template <path>", "Apply a template instead of scanning (local path or URL)")
+    .action((opts) => runInit({ dryRun: opts.dryRun, template: opts.template }));
 program
     .command("add")
     .description("Add a multi-file capability")
@@ -27,7 +31,8 @@ program
     .command("sync")
     .description("Update setup after project changes")
     .option("--dry-run", "Preview changes without writing")
-    .action((opts) => runSync({ dryRun: opts.dryRun }));
+    .option("--budget <tokens>", "Override token budget for this run", parseInt)
+    .action((opts) => runSync({ dryRun: opts.dryRun, budget: opts.budget }));
 program
     .command("status")
     .description("Show current setup state (instant, no file reads)")
@@ -36,11 +41,31 @@ program
     .command("doctor")
     .description("Validate environment — OS, MCP, hooks, env vars, skills")
     .option("-v, --verbose", "Show passing checks too")
-    .action((opts) => runDoctorCommand({ verbose: opts.verbose }));
+    .option("--fix", "Auto-fix issues where possible (model override, OS format, re-snapshot)")
+    .option("--test-hooks", "Run every hook once in sandbox, report pass/fail")
+    .action((opts) => runDoctorCommand({
+    verbose: opts.verbose,
+    fix: opts.fix,
+    testHooks: opts.testHooks,
+}));
 program
     .command("remove")
     .description("Remove a capability cleanly")
     .action(runRemove);
+// Feature A: Time-travel snapshot commands
+program
+    .command("restore")
+    .description("Jump to any snapshot node, restore files to that state")
+    .action(runRestore);
+program
+    .command("compare")
+    .description("Diff between any two snapshot nodes to see what changed")
+    .action(runCompare);
+// Feature H: Config template export
+program
+    .command("export")
+    .description("Save current project config as a reusable template")
+    .action(runExport);
 // Default action when no command given
 program.action(() => runInit({}));
 program.parse();

package/dist/manifest.d.ts

@@ -6,6 +6,12 @@ export interface ManifestRun {
     input?: string;
     filesRead: string[];
     snapshot: Record<string, string>;
+    estimatedTokens?: number;
+    estimatedCost?: {
+        opus: number;
+        sonnet: number;
+        haiku: number;
+    };
 }
 export interface Manifest {
     version: string;
@@ -17,4 +23,10 @@ export declare function readManifest(cwd?: string): Promise<Manifest | null>;
 export declare function updateManifest(command: string, collected: CollectedFiles, opts?: {
     input?: string;
     cwd?: string;
+    estimatedTokens?: number;
+    estimatedCost?: {
+        opus: number;
+        sonnet: number;
+        haiku: number;
+    };
 }): Promise<void>;

package/dist/manifest.js

@@ -70,6 +70,8 @@ export async function updateManifest(command, collected, opts = {}) {
         ...(opts.input ? { input: opts.input } : {}),
         filesRead,
         snapshot,
+        ...(opts.estimatedTokens ? { estimatedTokens: opts.estimatedTokens } : {}),
+        ...(opts.estimatedCost ? { estimatedCost: opts.estimatedCost } : {}),
     };
     let manifest;
     const existing = await readManifest(cwd);

package/dist/marketplace.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Marketplace intelligence — provides catalog info and decision logic
+ * for the add command to suggest plugins, skills, and MCP servers.
+ *
+ * Zero API calls at import time. Catalog is fetched only when needed.
+ */
+export declare const MARKETPLACE_REPO = "jeremylongshore/claude-code-plugins-plus-skills";
+export declare const MARKETPLACE_CATALOG_URL = "https://raw.githubusercontent.com/jeremylongshore/claude-code-plugins-plus-skills/main/.claude-plugin/marketplace.extended.json";
+/** The 20 skill categories in the marketplace */
+export declare const SKILL_CATEGORIES: readonly ["01-code-quality", "02-testing", "03-security", "04-devops", "05-api-development", "06-database", "07-frontend", "08-backend", "09-mobile", "10-data-science", "11-documentation", "12-project-management", "13-communication", "14-research", "15-content-creation", "16-business", "17-finance", "18-visual-content", "19-legal", "20-productivity"];
+/** SaaS packs available in the marketplace */
+export declare const SAAS_PACKS: readonly ["Supabase", "Vercel", "OpenRouter", "GitHub", "Azure", "MongoDB", "Playwright", "Tavily", "Stripe", "Slack", "Linear", "Notion"];
+/** Keyword-to-category mapping for classifying user requests */
+export declare const KEYWORD_CATEGORY_MAP: Record<string, string>;
+/** Classify a user request into marketplace categories */
+export declare function classifyRequest(input: string): {
+    categories: string[];
+    saasMatches: string[];
+};
+/** Generate marketplace search instructions for the add template */
+export declare function buildMarketplaceInstructions(input: string): string;