claude-setup 1.1.3 → 1.1.4

package/README.md

@@ -2,9 +2,9 @@
 
 Setup layer for Claude Code. Reads your project, writes command files, Claude Code does the rest.
 
-**The CLI has zero intelligence.** All reasoning is delegated to Claude Code via the command files. The CLI reads files. Claude Code decides.
+**The CLI has zero intelligence.** All reasoning is delegated to Claude Code via the command files.
 
-## Install & Quick Start
+## Install
 
 ```bash
 npx claude-setup init
@@ -16,47 +16,128 @@ Then open Claude Code and run `/stack-init`.
 
 | Command | What it does |
 |---------|-------------|
-| `npx claude-setup init` | Full project setup — new or existing. Detects empty projects automatically. |
-| `npx claude-setup add` | Add a multi-file capability (MCP + hooks + skills together) |
-| `npx claude-setup sync` | Update setup after project changes (uses diff, not full re-scan) |
-| `npx claude-setup status` | Show current setup state — OS, servers, hooks, staleness |
-| `npx claude-setup doctor` | Validate environment — OS/MCP format, hook quoting, env vars, stale skills |
-| `npx claude-setup remove` | Remove a capability cleanly with dangling reference detection |
+| `init` | Full project setup — detects empty projects, generates atomic setup steps |
+| `add` | Add capabilities — MCP servers, skills, hooks, plugins in one go |
+| `sync` | Update setup after project changes — diff-based, not full re-scan |
+| `status` | Dashboard — project info, setup files, snapshots, token usage |
+| `doctor` | Validate everything — OS format, hooks, env vars, stale skills |
+| `remove` | Remove capabilities cleanly with dangling reference detection |
+| `restore` | Jump to any snapshot — restore files to a previous state |
+| `compare` | Diff two snapshots — find exactly where something changed |
+| `export` | Save your setup as a reusable template |
 
 ### Flags
 
 ```bash
-npx claude-setup init --dry-run    # Preview without writing
-npx claude-setup sync --dry-run    # Show changes without writing
-npx claude-setup doctor --verbose  # Include passing checks in output
+npx claude-setup init --dry-run            # Preview without writing
+npx claude-setup init --template my.json   # Apply a saved template
+npx claude-setup sync --dry-run            # Show changes without writing
+npx claude-setup sync --budget 3000        # Override token budget
+npx claude-setup doctor --verbose          # Include passing checks
+npx claude-setup doctor --fix              # Auto-fix issues
+npx claude-setup doctor --test-hooks       # Run every hook in sandbox
 ```
 
 ## How it works
 
-1. **CLI collects** — reads project files (configs, source samples) with strict token cost controls
-2. **CLI writes command files** — assembles markdown instructions into `.claude/commands/`
-3. **Claude Code executes** — you run `/stack-init` (or `/stack-sync`, etc.) in Claude Code
+1. **CLI collects** — reads project files with strict token cost controls
+2. **CLI writes** — generates markdown instructions into `.claude/commands/`
+3. **Claude Code executes** — you run `/stack-init`, `/stack-sync`, etc.
 
-## Three project states
+## What it creates
 
-- **Empty project** — Claude Code asks 3 discovery questions, then sets up a tailored environment
-- **In development** — reads existing files, writes setup that references actual code patterns
-- **Production** — same as development; merge rules protect existing Claude config (append only, never rewrite)
+| File | Purpose |
+|------|---------|
+| `CLAUDE.md` | Project-specific context for Claude Code |
+| `.mcp.json` | MCP server connections (only if evidenced by project files) |
+| `.claude/settings.json` | Hooks in correct Claude Code format |
+| `.claude/skills/` | Reusable patterns with frontmatter |
+| `.claude/commands/` | Project-specific slash commands |
+| `.github/workflows/` | CI workflows (only with confirmation) |
 
-## What it creates
+## Snapshots
+
+Every `init` and `sync` creates a snapshot node — a checkpoint on a timeline. Snapshots store the content of changed files only.
+
+```
+init ──→ sync#1 ──→ sync#2 ──→ sync#3 (current)
+              │                    │
+              │                    └─ bug introduced here
+              └─ jump back here
+```
+
+- `npx claude-setup restore` — pick any snapshot and restore files to that state
+- `npx claude-setup compare` — diff any two snapshots to find what changed
+- Jumping does **not** delete other snapshots — all are preserved
+
+## Templates
+
+Save your setup and reuse it across projects.
 
-- `CLAUDE.md` — project-specific context for Claude Code
-- `.mcp.json` — MCP server connections (only if evidenced by project files, OS-correct format)
-- `.claude/settings.json` — hooks (only if warranted, OS-correct shell format)
-- `.claude/skills/` — reusable patterns (only if recurring, with `applies-when` frontmatter)
-- `.claude/commands/` — project-specific slash commands
-- `.github/workflows/` — CI workflows (only if `.github/` exists)
+```bash
+# Export current setup
+npx claude-setup export
+# → creates my-template.claude-template.json
+
+# Apply to a new project
+npx claude-setup init --template my-template.claude-template.json
+
+# Apply from a URL
+npx claude-setup init --template https://example.com/template.json
+```
+
+Templates capture CLAUDE.md, MCP servers, hooks, skills, and commands. On import:
+- Existing content is kept, new content is merged
+- MCP commands are auto-adapted for the target OS
+- Skills and commands with the same name are skipped
 
+## Token Cost Tracking
+
+Every command shows estimated token usage and cost across all Claude models.
+
+```
+Token cost
+  ~2,450 input tokens (Opus $0.0368 | Sonnet $0.0074 | Haiku $0.0006)
+```
 
+Status shows cumulative stats, per-command averages, and cost trends. Use `--budget` on sync to override the token limit for a single run.
+
+## Doctor
+
+Validates your entire setup and reports issues by severity.
+
+```bash
+npx claude-setup doctor           # Check everything
+npx claude-setup doctor --fix     # Auto-fix what's possible
+npx claude-setup doctor --test-hooks  # Run each hook, report pass/fail
+```
+
+What `--fix` can repair:
+- Remove accidental model overrides from settings.json
+- Convert MCP commands to the correct OS format
+- Add missing `-y` flags to npx calls
+- Re-snapshot files modified outside the CLI
+
+What `--test-hooks` checks per hook:
+- Command exists on the system
+- Command executes without error
+- Exit code and stderr
+- Execution time and timeout detection
+- Matcher regex validity
+
+## Marketplace
+
+The `add` command integrates with [claude-code-plugins-plus-skills](https://github.com/jeremylongshore/claude-code-plugins-plus-skills) — 340+ plugins and 1,367+ skills across 20 categories.
+
+```bash
+npx claude-setup add
+# → "Stripe and frontend skills"
+# → generates stack-add.md with marketplace search + install instructions
+```
 
 ## Configuration
 
-Create `.claude-setup.json` in your project root to customize:
+Auto-generated on first run. Edit `.claude-setup.json` to customize:
 
 ```json
 {
@@ -70,27 +151,11 @@ Create `.claude-setup.json` in your project root to customize:
     "remove": 2000
   },
   "digestMode": true,
-  "extraBlockedDirs": ["my-custom-dir"],
-  "sourceDirs": ["src", "lib"]
+  "extraBlockedDirs": [],
+  "sourceDirs": []
 }
 ```
 
-## Digest mode
-
-When `digestMode` is enabled (default), the CLI extracts compact signal instead of dumping raw file content:
-
-- **Config files found** — just names, not content
-- **Dependencies** — extracted from any package manifest
-- **Scripts** — available commands/tasks
-- **Env vars** — names from `.env.example`
-- **Directory tree** — compact structure (3 levels deep)
-- **Source signatures** — imports, exports, declarations (not full content)
-
-## OS detection
-
-The CLI detects your OS and ensures command files tell Claude Code to use the correct format:
-
-- **Windows**: `{ "command": "cmd", "args": ["/c", "npx", "<package>"] }`
-- **macOS/Linux**: `{ "command": "npx", "args": ["<package>"] }`
+## License
 
-`doctor` checks for mismatches and reports them as critical issues.
+MIT

package/dist/builder.js

@@ -3,6 +3,7 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { loadConfig } from "./config.js";
 import { detectOS, VERIFIED_MCP_PACKAGES } from "./os.js";
+import { buildMarketplaceInstructions } from "./marketplace.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const TEMPLATES_DIR = join(__dirname, "..", "templates");
 function estimateTokens(content) {
@@ -97,6 +98,7 @@ function buildFlags(_collected, state) {
         HAS_MCP_JSON: state.mcpJson.exists,
         HAS_SETTINGS: state.settings.exists,
         HAS_GITHUB_DIR: state.hasGithubDir,
+        IS_WINDOWS: detectOS() === "Windows",
     };
 }
 // --- Token budget enforcement ---
@@ -137,10 +139,18 @@ export function buildInitCommand(collected, state) {
 }
 export function buildEmptyProjectCommand() {
     const template = loadTemplate("init-empty.md");
-    return replaceVars(template, { VERSION: getVersion(), DATE: new Date().toISOString().split("T")[0] });
+    const vars = { VERSION: getVersion(), DATE: new Date().toISOString().split("T")[0], DETECTED_OS: detectOS() };
+    const flags = { IS_WINDOWS: detectOS() === "Windows" };
+    let content = replaceVars(template, vars);
+    content = processConditionals(content, flags);
+    return content;
 }
 export function buildAddCommand(input, collected, state) {
-    return applyTemplate("add.md", collected, state, { USER_INPUT: input }, "add");
+    const marketplaceSection = buildMarketplaceInstructions(input);
+    return applyTemplate("add.md", collected, state, {
+        USER_INPUT: input,
+        MARKETPLACE_INSTRUCTIONS: marketplaceSection,
+    }, "add");
 }
 export function buildSyncCommand(diff, collected, state) {
     // Compact diff format — paths + one-line summary, not full content
@@ -214,11 +224,13 @@ export function buildAtomicSteps(collected, state) {
                     ? `### Current content — MERGE ONLY, never remove existing entries:\n${vars.MCP_JSON_CONTENT}\n\n`
                     : `Does not exist.\n\n`) +
                 `### When to create/update\n` +
-                `Add an MCP server ONLY if you find evidence in /stack-0-context:\n` +
-                `- Import statement referencing an external service\n` +
-                `- docker-compose service (database, cache, queue)\n` +
-                `- Env var name in .env.example matching a known service pattern\n` +
-                `- Explicit dependency on an MCP-compatible package\n\n` +
+                `Add an MCP server if you find ANY of these signals in /stack-0-context:\n` +
+                `- Import statement referencing an external service (e.g., pg, mysql2, mongoose, redis, stripe)\n` +
+                `- docker-compose service (database, cache, queue, message broker)\n` +
+                `- Env var name in .env.example matching a known service pattern (DATABASE_URL, REDIS_URL, STRIPE_KEY, etc.)\n` +
+                `- Explicit dependency on an MCP-compatible package\n` +
+                `- User mentioned external services during init questions\n\n` +
+                `If ANY evidence is found, create .mcp.json with the corresponding servers.\n` +
                 `No evidence = no server. Do not invent services.\n\n` +
                 `### Verified MCP package names — ONLY use these\n` +
                 `\`\`\`\n` +
@@ -273,21 +285,53 @@ export function buildAtomicSteps(collected, state) {
                 `### When to create/update\n` +
                 `Add a hook ONLY if it runs on a pattern that repeats every session AND the cost is justified.\n` +
                 `Every hook adds overhead on every Claude Code action. Only add if clearly earned.\n\n` +
-                `### OS-correct hook format (detected: ${os})\n` +
+                `### CORRECT Claude Code hooks format — USE THIS EXACTLY\n` +
+                `The hooks object must be nested inside a top-level \`"hooks"\` key.\n` +
+                `Each event contains an array of matcher objects, each with its own \`"hooks"\` array.\n\n` +
+                `\`\`\`json\n` +
+                `{\n` +
+                `  "hooks": {\n` +
+                `    "PostToolUse": [\n` +
+                `      {\n` +
+                `        "matcher": "Edit|Write",\n` +
+                `        "hooks": [\n` +
+                `          {\n` +
+                `            "type": "command",\n` +
+                `            "command": "<shell command here>"\n` +
+                `          }\n` +
+                `        ]\n` +
+                `      }\n` +
+                `    ]\n` +
+                `  }\n` +
+                `}\n` +
+                `\`\`\`\n\n` +
+                `**WRONG formats (do NOT use):**\n` +
+                `- \`"hooks": { "post-edit": ["mvn compile"] }\` — INVALID event name and structure\n` +
+                `- \`"PostToolUse": [{ "command": "bash", "args": [...] }]\` — missing top-level "hooks" key\n` +
+                `- \`{ "command": "cmd", "args": ["/c", "..."] }\` — old format, must use "type": "command"\n\n` +
+                `### Valid hook event names — use ONLY these\n` +
+                `\`PreToolUse\`, \`PostToolUse\`, \`PostToolUseFailure\`, \`Stop\`, \`SessionStart\`,\n` +
+                `\`Notification\`, \`UserPromptSubmit\`, \`PermissionRequest\`, \`ConfigChange\`,\n` +
+                `\`SubagentStart\`, \`SubagentStop\`, \`SessionEnd\`\n\n` +
+                `### Matcher patterns\n` +
+                `- \`"Edit|Write"\` — fires only on file edits\n` +
+                `- \`"Bash"\` — fires only on shell commands\n` +
+                `- \`""\` (empty) — fires on all occurrences of the event\n\n` +
+                `### BUG 8 FIX: Verify build tools exist BEFORE adding hooks\n` +
+                `Before adding any hook that runs a build tool, verify it is installed:\n` +
                 (os === "Windows"
-                    ? `Use: \`{ "command": "cmd", "args": ["/c", "<command>"] }\`\n`
-                    : `Use: \`{ "command": "bash", "args": ["-c", "<command>"] }\`\n` +
-                        `**Bash quoting rule**: never use bare \`"\` inside \`-c "..."\` — use \`\\x22\` instead.\n` +
-                        `Replace \`'\` with \`\\x27\`, \`$\` in character classes with \`\\x24\`.\n`) +
-                `\n### Valid hook event names — use ONLY these\n` +
-                `\`PreToolUse\`, \`PostToolUse\`, \`PostToolUseFailure\`, \`Stop\`, \`SessionStart\`\n` +
-                `If unsure which event name to use: do not write the hook. Print:\n` +
-                `\`SKIPPED — hook event name uncertain. Valid names: PreToolUse, PostToolUse, PostToolUseFailure, Stop, SessionStart\`\n\n` +
+                    ? `\`\`\`\nwhere mvn 2>nul && mvn compile -q\nwhere gradle 2>nul && gradle build\nwhere npm 2>nul && npm run build\n\`\`\`\n`
+                    : `\`\`\`\ncommand -v mvn && mvn compile -q\ncommand -v gradle && gradle build\ncommand -v npm && npm run build\n\`\`\`\n`) +
+                `If the tool is NOT installed:\n` +
+                `- Wrap the command with an existence check: \`command -v mvn && mvn compile -q\`\n` +
+                `- OR skip the hook and print: \`⚠️ SKIPPED mvn hook — Maven not found. Install Maven first.\`\n` +
+                `- NEVER add a hook for a tool that doesn't exist on the system\n\n` +
                 `### Rules\n` +
                 `- **NEVER write a "model" key into settings.json** — it overrides the user's model selection silently\n` +
                 `- If it exists above: audit quoting of existing hooks first, fix broken ones\n` +
                 `- Only add hooks for patterns that genuinely recur for this project type\n` +
-                `- Produce valid JSON only\n\n` +
+                `- Produce valid JSON only\n` +
+                `- The \`"type"\` field in each hook must be one of: \`"command"\`, \`"prompt"\`, \`"agent"\`, \`"http"\`\n\n` +
                 `### Output\n` +
                 `Created/Updated: ✅ settings.json — [hook name and justification]\n` +
                 `Skipped: ⏭ settings.json — [why no hooks warranted]\n`,
@@ -299,16 +343,37 @@ export function buildAtomicSteps(collected, state) {
                 `## Target: .claude/skills/\n` +
                 `Installed: ${vars.SKILLS_LIST}\n\n` +
                 `### When to create\n` +
-                `Create a skill ONLY if:\n` +
+                `Create a skill if:\n` +
                 `- A recurring multi-step project-specific pattern exists in /stack-0-context\n` +
-                `- It is NOT something Claude already knows (standard patterns don't need skills)\n` +
+                `- The project type has standard workflows worth automating (build, deploy, test patterns)\n` +
                 `- It will save time across multiple Claude Code sessions\n\n` +
+                `### Correct skill file format\n` +
+                `Skills must be created as \`.claude/skills/<skill-name>/SKILL.md\` with YAML frontmatter:\n\n` +
+                `\`\`\`yaml\n` +
+                `---\n` +
+                `name: skill-name\n` +
+                `description: What this skill does and when to use it\n` +
+                `---\n\n` +
+                `Skill instructions here...\n` +
+                `\`\`\`\n\n` +
+                `Optional frontmatter fields:\n` +
+                `- \`disable-model-invocation: true\` — only user can invoke (for commands with side effects)\n` +
+                `- \`allowed-tools: Read, Grep\` — restrict which tools the skill can use\n` +
+                `- \`context: fork\` — run in isolated subagent\n` +
+                `- \`agent: Explore\` — which agent type to use with context: fork\n\n` +
+                `### Project-specific skills to consider\n` +
+                `Based on what you see in /stack-0-context, consider creating skills for:\n` +
+                `- Build/deploy workflows specific to this stack\n` +
+                `- Code review patterns specific to this codebase\n` +
+                `- Database migration patterns if migration files exist\n` +
+                `- Testing patterns if test infrastructure exists\n\n` +
                 `### Rules\n` +
-                `- Use \`applies-when:\` frontmatter so skills load only when relevant, not every message\n` +
+                `- Use \`description:\` frontmatter so Claude knows when to load the skill\n` +
                 `- If a similar skill already exists above: extend it, don't create a parallel one\n` +
-                `- Empty is valid — no skills is better than useless skills\n\n` +
+                `- Empty is valid — no skills is better than useless skills\n` +
+                `- Each skill directory MUST contain a SKILL.md file\n\n` +
                 `### Output\n` +
-                `Created: ✅ .claude/skills/[name] — [what pattern it captures]\n` +
+                `Created: ✅ .claude/skills/[name]/SKILL.md — [what pattern it captures]\n` +
                 `Skipped: ⏭ skills — checked [patterns], found [nothing project-specific]\n`,
         },
         // --- Step 5: .claude/commands/ ---
@@ -431,12 +496,12 @@ export function buildOrchestratorCommand(steps) {
     const stepList = runSteps
         .map((s, i) => `${i + 1}. /${s.filename.replace(".md", "")}`)
         .join("\n");
-    return `<!-- claude-setup ${version} ${date} -->
-
-Run these in order. If one fails, fix and continue from that step.
-
-${stepList}
-
-After all complete: one-line summary of what was created.
+    return `<!-- claude-setup ${version} ${date} -->
+
+Run these in order. If one fails, fix and continue from that step.
+
+${stepList}
+
+After all complete: one-line summary of what was created.
 `;
 }

package/dist/commands/add.js

@@ -4,7 +4,8 @@ import { collectProjectFiles } from "../collect.js";
 import { readState } from "../state.js";
 import { updateManifest } from "../manifest.js";
 import { buildAddCommand } from "../builder.js";
-import { c } from "../output.js";
+import { estimateTokens, estimateCost } from "../tokens.js";
+import { c, section } from "../output.js";
 function ensureDir(dir) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
@@ -46,8 +47,18 @@ capabilities that need documentation, MCP servers, skills, and hooks together.
     // add only needs config files — source files are irrelevant and waste tokens
     const collected = await collectProjectFiles(process.cwd(), "configOnly");
     const content = buildAddCommand(userInput, collected, state);
+    // Token tracking
+    const tokens = estimateTokens(content);
+    const cost = estimateCost(tokens);
     ensureDir(".claude/commands");
     writeFileSync(".claude/commands/stack-add.md", content, "utf8");
-    await updateManifest("add", collected, { input: userInput });
-    console.log(`\n${c.green("✅")} Ready. Open Claude Code and run:\n   ${c.cyan("/stack-add")}\n`);
+    await updateManifest("add", collected, {
+        input: userInput,
+        estimatedTokens: tokens,
+        estimatedCost: cost,
+    });
+    console.log(`\n${c.green("✅")} Ready. Open Claude Code and run:\n   ${c.cyan("/stack-add")}`);
+    section("Token cost");
+    console.log(`  ~${tokens.toLocaleString()} input tokens (${c.dim(`Opus $${cost.opus.toFixed(4)} | Sonnet $${cost.sonnet.toFixed(4)} | Haiku $${cost.haiku.toFixed(4)}`)})`);
+    console.log("");
 }

package/dist/commands/compare.d.ts

@@ -0,0 +1 @@
+export declare function runCompare(): Promise<void>;

package/dist/commands/compare.js

@@ -0,0 +1,84 @@
+import { readTimeline, compareSnapshots } from "../snapshot.js";
+import { c, section } from "../output.js";
+import { createInterface } from "readline";
+async function promptFreeText(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question + " ", (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function runCompare() {
+    const cwd = process.cwd();
+    const timeline = readTimeline(cwd);
+    if (timeline.nodes.length < 2) {
+        console.log(`${c.yellow("⚠️")} Need at least 2 snapshots to compare. ` +
+            `Run ${c.cyan("npx claude-setup sync")} to create more.`);
+        return;
+    }
+    // Display available nodes
+    section("Available snapshots");
+    console.log("");
+    for (let i = 0; i < timeline.nodes.length; i++) {
+        const node = timeline.nodes[i];
+        const date = new Date(node.timestamp).toLocaleString();
+        const inputStr = node.input ? ` "${node.input}"` : "";
+        console.log(`  ${c.cyan(node.id)}  ${node.command}${inputStr}  ${c.dim(date)}  ${node.summary}`);
+    }
+    console.log("");
+    const idA = await promptFreeText("Enter first snapshot ID (older):");
+    if (!idA) {
+        console.log("No input provided.");
+        return;
+    }
+    const idB = await promptFreeText("Enter second snapshot ID (newer):");
+    if (!idB) {
+        console.log("No input provided.");
+        return;
+    }
+    const nodeA = timeline.nodes.find(n => n.id === idA);
+    const nodeB = timeline.nodes.find(n => n.id === idB);
+    if (!nodeA) {
+        console.log(`${c.red("🔴")} Snapshot "${idA}" not found.`);
+        return;
+    }
+    if (!nodeB) {
+        console.log(`${c.red("🔴")} Snapshot "${idB}" not found.`);
+        return;
+    }
+    console.log(`\nComparing ${c.cyan(idA)} → ${c.cyan(idB)}...\n`);
+    const result = compareSnapshots(cwd, idA, idB);
+    if (result.onlyInA.length) {
+        section(`Only in ${idA} (removed after)`);
+        for (const f of result.onlyInA) {
+            console.log(`  ${c.red("-")} ${f}`);
+        }
+    }
+    if (result.onlyInB.length) {
+        section(`Only in ${idB} (added after)`);
+        for (const f of result.onlyInB) {
+            console.log(`  ${c.green("+")} ${f}`);
+        }
+    }
+    if (result.changed.length) {
+        section("Changed between snapshots");
+        for (const f of result.changed) {
+            console.log(`  ${c.yellow("~")} ${f.path} (${f.linesA} → ${f.linesB} lines)`);
+        }
+    }
+    if (result.identical.length) {
+        console.log(`\n  ${c.dim(`${result.identical.length} file(s) identical between snapshots`)}`);
+    }
+    const totalDiffs = result.onlyInA.length + result.onlyInB.length + result.changed.length;
+    if (totalDiffs === 0) {
+        console.log(`\n${c.green("✅")} Snapshots are identical — no differences found.`);
+    }
+    else {
+        console.log(`\n${c.bold(`${totalDiffs} difference(s)`)} between ${c.cyan(idA)} and ${c.cyan(idB)}.`);
+        if (result.changed.length) {
+            console.log(`${c.dim("Use")} ${c.cyan("npx claude-setup restore")} ${c.dim("to jump to either snapshot.")}`);
+        }
+    }
+}

package/dist/commands/doctor.d.ts

@@ -2,4 +2,6 @@ import { runDoctor } from "../doctor.js";
 export { runDoctor };
 export declare function runDoctorCommand(opts?: {
     verbose?: boolean;
+    fix?: boolean;
+    testHooks?: boolean;
 }): Promise<void>;

package/dist/commands/doctor.js

@@ -1,5 +1,5 @@
 import { runDoctor } from "../doctor.js";
 export { runDoctor };
 export async function runDoctorCommand(opts = {}) {
-    return runDoctor(opts.verbose ?? false);
+    return runDoctor(opts.verbose ?? false, opts.fix ?? false, opts.testHooks ?? false);
 }

package/dist/commands/export.d.ts

@@ -0,0 +1,25 @@
+export interface ConfigTemplate {
+    name: string;
+    version: "1";
+    exportedAt: string;
+    exportedFrom: string;
+    os: string;
+    claudeMd?: string;
+    mcpJson?: Record<string, unknown>;
+    settings?: Record<string, unknown>;
+    skills: Array<{
+        name: string;
+        content: string;
+    }>;
+    commands: Array<{
+        name: string;
+        content: string;
+    }>;
+}
+export declare function runExport(): Promise<void>;
+/**
+ * Apply a template to the current project.
+ * Merge logic: existing content kept, new content added.
+ * OS adaptation: MCP commands auto-converted for target OS.
+ */
+export declare function applyTemplate(templateSource: string): Promise<void>;