planmode 0.1.5 → 0.2.1

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command11 } from "commander";
+import { Command as Command16 } from "commander";
 
 // src/commands/install.ts
 import { Command } from "commander";
@@ -399,6 +399,18 @@ function removeImport(planName, projectDir = process.cwd()) {
   const updated = content.split("\n").filter((line) => line.trim() !== importLine).join("\n");
   fs5.writeFileSync(claudeMdPath, updated, "utf-8");
 }
+function listImports(projectDir = process.cwd()) {
+  const claudeMdPath = getClaudeMdPath(projectDir);
+  if (!fs5.existsSync(claudeMdPath)) return [];
+  const content = fs5.readFileSync(claudeMdPath, "utf-8");
+  const importRegex = /^-\s*@plans\/(.+)\.md$/gm;
+  const imports = [];
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    imports.push(match[1]);
+  }
+  return imports;
+}
 
 // src/lib/manifest.ts
 import fs6 from "fs";
@@ -581,38 +593,96 @@ var YELLOW = "\x1B[33m";
 var CYAN = "\x1B[36m";
 var DIM = "\x1B[2m";
 var BOLD = "\x1B[1m";
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+var capturing = false;
+var captured = [];
 var logger = {
+  capture() {
+    capturing = true;
+    captured = [];
+  },
+  flush() {
+    const messages = captured;
+    captured = [];
+    capturing = false;
+    return messages;
+  },
+  isCapturing() {
+    return capturing;
+  },
   info(msg) {
-    console.log(`${CYAN}info${RESET} ${msg}`);
+    const text = `info ${msg}`;
+    if (capturing) {
+      captured.push(stripAnsi(text));
+    } else {
+      console.log(`${CYAN}info${RESET} ${msg}`);
+    }
   },
   success(msg) {
-    console.log(`${GREEN}\u2713${RESET} ${msg}`);
+    const text = `\u2713 ${msg}`;
+    if (capturing) {
+      captured.push(stripAnsi(text));
+    } else {
+      console.log(`${GREEN}\u2713${RESET} ${msg}`);
+    }
   },
   warn(msg) {
-    console.log(`${YELLOW}warn${RESET} ${msg}`);
+    const text = `warn ${msg}`;
+    if (capturing) {
+      captured.push(stripAnsi(text));
+    } else {
+      console.log(`${YELLOW}warn${RESET} ${msg}`);
+    }
   },
   error(msg) {
-    console.error(`${RED}error${RESET} ${msg}`);
+    const text = `error ${msg}`;
+    if (capturing) {
+      captured.push(stripAnsi(text));
+    } else {
+      console.error(`${RED}error${RESET} ${msg}`);
+    }
   },
   dim(msg) {
-    console.log(`${DIM}${msg}${RESET}`);
+    if (capturing) {
+      captured.push(msg);
+    } else {
+      console.log(`${DIM}${msg}${RESET}`);
+    }
   },
   bold(msg) {
-    console.log(`${BOLD}${msg}${RESET}`);
+    if (capturing) {
+      captured.push(msg);
+    } else {
+      console.log(`${BOLD}${msg}${RESET}`);
+    }
   },
   table(headers, rows) {
     const colWidths = headers.map(
       (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length))
     );
     const header = headers.map((h, i) => h.toUpperCase().padEnd(colWidths[i])).join("  ");
-    console.log(`  ${DIM}${header}${RESET}`);
-    for (const row of rows) {
-      const line = row.map((cell, i) => cell.padEnd(colWidths[i])).join("  ");
-      console.log(`  ${line}`);
+    if (capturing) {
+      captured.push(`  ${header}`);
+      for (const row of rows) {
+        const line = row.map((cell, i) => cell.padEnd(colWidths[i])).join("  ");
+        captured.push(`  ${line}`);
+      }
+    } else {
+      console.log(`  ${DIM}${header}${RESET}`);
+      for (const row of rows) {
+        const line = row.map((cell, i) => cell.padEnd(colWidths[i])).join("  ");
+        console.log(`  ${line}`);
+      }
     }
   },
   blank() {
-    console.log();
+    if (capturing) {
+      captured.push("");
+    } else {
+      console.log();
+    }
   }
 };
 
@@ -695,13 +765,26 @@ async function installPackage(packageName, options = {}) {
       logger.warn(`Overwriting ${installPath} with new content`);
     }
   }
+  const computedHash = contentHash(content);
+  if (versionMeta.content_hash && computedHash !== versionMeta.content_hash) {
+    logger.warn(
+      `Content hash mismatch for ${packageName}@${version}. Expected ${versionMeta.content_hash.slice(0, 20)}..., got ${computedHash.slice(0, 20)}... The package content may have been modified after review.`
+    );
+  }
   fs7.mkdirSync(path7.dirname(fullPath), { recursive: true });
   fs7.writeFileSync(fullPath, content, "utf-8");
   logger.success(`Installed ${packageName}@${version} \u2192 ${installPath}`);
   trackDownload(packageName);
   if (type === "plan") {
     addImport(packageName, projectDir);
-    logger.dim(`Added @import to CLAUDE.md`);
+    logger.dim(`Added @plans/${packageName}.md to CLAUDE.md`);
+    logger.dim(`Claude Code will automatically see this plan in your next conversation.`);
+  }
+  if (type === "rule") {
+    logger.dim(`Rule is active \u2014 Claude Code auto-loads all files in .claude/rules/.`);
+  }
+  if (type === "prompt") {
+    logger.dim(`Run it with: planmode run ${packageName}`);
   }
   const hash = contentHash(content);
   const entry = {
@@ -905,144 +988,143 @@ var runCommand = new Command4("run").description("Run a templated prompt and out
 
 // src/commands/publish.ts
 import { Command as Command5 } from "commander";
-var publishCommand = new Command5("publish").description("Publish the current directory as a package to the registry").action(async () => {
+
+// src/lib/publisher.ts
+async function publishPackage(options = {}) {
+  const cwd = options.projectDir ?? process.cwd();
+  const token = options.token ?? getGitHubToken();
+  if (!token) {
+    throw new Error("Not authenticated. Run `planmode login` first.");
+  }
+  logger.info("Reading planmode.yaml...");
+  const manifest = readManifest(cwd);
+  const errors = validateManifest(manifest, true);
+  if (errors.length > 0) {
+    throw new Error(`Invalid manifest:
+${errors.map((e) => `  - ${e}`).join("\n")}`);
+  }
+  const remoteUrl = await getRemoteUrl(cwd);
+  if (!remoteUrl) {
+    throw new Error("No git remote found. Push your code to GitHub first.");
+  }
+  const sha = await getHeadSha(cwd);
+  const tag = `v${manifest.version}`;
+  logger.info(`Creating tag ${tag}...`);
   try {
-    const cwd = process.cwd();
-    const token = getGitHubToken();
-    if (!token) {
-      logger.error("Not authenticated. Run `planmode login` first.");
-      process.exit(1);
-    }
-    logger.info("Reading planmode.yaml...");
-    const manifest = readManifest(cwd);
-    const errors = validateManifest(manifest, true);
-    if (errors.length > 0) {
-      logger.error("Invalid manifest:");
-      for (const err of errors) {
-        console.log(`  - ${err}`);
-      }
-      process.exit(1);
-    }
-    const remoteUrl = await getRemoteUrl(cwd);
-    if (!remoteUrl) {
-      logger.error("No git remote found. Push your code to GitHub first.");
-      process.exit(1);
-    }
-    const sha = await getHeadSha(cwd);
-    const tag = `v${manifest.version}`;
-    logger.info(`Creating tag ${tag}...`);
-    try {
-      await createTag(cwd, tag);
-    } catch {
-      logger.dim(`Tag ${tag} already exists, using existing`);
-    }
-    try {
-      await pushTag(cwd, tag);
-      logger.success(`Pushed tag ${tag}`);
-    } catch {
-      logger.dim(`Tag ${tag} already pushed`);
-    }
-    logger.info("Submitting to registry...");
-    const headers = {
-      Authorization: `Bearer ${token}`,
-      Accept: "application/vnd.github.v3+json",
-      "User-Agent": "planmode-cli",
-      "Content-Type": "application/json"
-    };
-    await fetch("https://api.github.com/repos/kaihannonen/planmode.org/forks", {
-      method: "POST",
-      headers
-    });
-    const userRes = await fetch("https://api.github.com/user", { headers });
-    const user = await userRes.json();
-    const metadataContent = JSON.stringify(
-      {
-        name: manifest.name,
-        description: manifest.description,
-        author: manifest.author,
-        license: manifest.license,
-        repository: remoteUrl.replace(/^https?:\/\//, "").replace(/\.git$/, ""),
-        category: manifest.category ?? "other",
-        tags: manifest.tags ?? [],
-        type: manifest.type,
-        models: manifest.models ?? [],
-        latest_version: manifest.version,
-        versions: [manifest.version],
-        downloads: 0,
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-        dependencies: manifest.dependencies,
-        variables: manifest.variables
-      },
-      null,
-      2
-    );
-    const versionContent = JSON.stringify(
-      {
-        version: manifest.version,
-        published_at: (/* @__PURE__ */ new Date()).toISOString(),
-        source: {
-          repository: remoteUrl.replace(/^https?:\/\//, "").replace(/\.git$/, ""),
-          tag,
-          sha
-        },
-        files: ["planmode.yaml", manifest.content_file ?? "inline"],
-        content_hash: `sha256:${sha.slice(0, 16)}`
+    await createTag(cwd, tag);
+  } catch {
+    logger.dim(`Tag ${tag} already exists, using existing`);
+  }
+  try {
+    await pushTag(cwd, tag);
+    logger.success(`Pushed tag ${tag}`);
+  } catch {
+    logger.dim(`Tag ${tag} already pushed`);
+  }
+  logger.info("Submitting to registry...");
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "planmode-cli",
+    "Content-Type": "application/json"
+  };
+  await fetch("https://api.github.com/repos/kaihannonen/planmode.org/forks", {
+    method: "POST",
+    headers
+  });
+  const userRes = await fetch("https://api.github.com/user", { headers });
+  if (!userRes.ok) {
+    throw new Error("Failed to authenticate with GitHub. Check your token.");
+  }
+  const user = await userRes.json();
+  const repoPath = remoteUrl.replace(/^https?:\/\//, "").replace(/\.git$/, "");
+  const metadataContent = JSON.stringify(
+    {
+      name: manifest.name,
+      description: manifest.description,
+      author: manifest.author,
+      license: manifest.license,
+      repository: repoPath,
+      category: manifest.category ?? "other",
+      tags: manifest.tags ?? [],
+      type: manifest.type,
+      models: manifest.models ?? [],
+      latest_version: manifest.version,
+      versions: [manifest.version],
+      downloads: 0,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      dependencies: manifest.dependencies,
+      variables: manifest.variables
+    },
+    null,
+    2
+  );
+  const versionContent = JSON.stringify(
+    {
+      version: manifest.version,
+      published_at: (/* @__PURE__ */ new Date()).toISOString(),
+      source: {
+        repository: repoPath,
+        tag,
+        sha
       },
-      null,
-      2
-    );
-    const branchName = `add-${manifest.name}-${manifest.version}`;
-    const refRes = await fetch(
-      `https://api.github.com/repos/${user.login}/planmode.org/git/ref/heads/main`,
-      { headers }
-    );
-    if (!refRes.ok) {
-      logger.error("Failed to access registry fork. Make sure the fork exists.");
-      process.exit(1);
-    }
-    const refData = await refRes.json();
-    const baseSha = refData.object.sha;
-    await fetch(`https://api.github.com/repos/${user.login}/planmode.org/git/refs`, {
-      method: "POST",
+      files: ["planmode.yaml", manifest.content_file ?? "inline"],
+      content_hash: `sha256:${sha.slice(0, 16)}`
+    },
+    null,
+    2
+  );
+  const branchName = `add-${manifest.name}-${manifest.version}`;
+  const refRes = await fetch(
+    `https://api.github.com/repos/${user.login}/planmode.org/git/ref/heads/main`,
+    { headers }
+  );
+  if (!refRes.ok) {
+    throw new Error("Failed to access registry fork. Make sure the fork exists.");
+  }
+  const refData = await refRes.json();
+  const baseSha = refData.object.sha;
+  await fetch(`https://api.github.com/repos/${user.login}/planmode.org/git/refs`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      ref: `refs/heads/${branchName}`,
+      sha: baseSha
+    })
+  });
+  await fetch(
+    `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/metadata.json`,
+    {
+      method: "PUT",
       headers,
       body: JSON.stringify({
-        ref: `refs/heads/${branchName}`,
-        sha: baseSha
+        message: `Add ${manifest.name}@${manifest.version}`,
+        content: Buffer.from(metadataContent).toString("base64"),
+        branch: branchName
       })
-    });
-    await fetch(
-      `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/metadata.json`,
-      {
-        method: "PUT",
-        headers,
-        body: JSON.stringify({
-          message: `Add ${manifest.name}@${manifest.version}`,
-          content: Buffer.from(metadataContent).toString("base64"),
-          branch: branchName
-        })
-      }
-    );
-    await fetch(
-      `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/versions/${manifest.version}.json`,
-      {
-        method: "PUT",
-        headers,
-        body: JSON.stringify({
-          message: `Add ${manifest.name}@${manifest.version} version metadata`,
-          content: Buffer.from(versionContent).toString("base64"),
-          branch: branchName
-        })
-      }
-    );
-    const prRes = await fetch("https://api.github.com/repos/kaihannonen/planmode.org/pulls", {
-      method: "POST",
+    }
+  );
+  await fetch(
+    `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/versions/${manifest.version}.json`,
+    {
+      method: "PUT",
       headers,
       body: JSON.stringify({
-        title: `Add ${manifest.name}@${manifest.version}`,
-        head: `${user.login}:${branchName}`,
-        base: "main",
-        body: `## New package: ${manifest.name}
+        message: `Add ${manifest.name}@${manifest.version} version metadata`,
+        content: Buffer.from(versionContent).toString("base64"),
+        branch: branchName
+      })
+    }
+  );
+  const prRes = await fetch("https://api.github.com/repos/kaihannonen/planmode.org/pulls", {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      title: `Add ${manifest.name}@${manifest.version}`,
+      head: `${user.login}:${branchName}`,
+      base: "main",
+      body: `## New package: ${manifest.name}
 
 - **Type:** ${manifest.type}
 - **Version:** ${manifest.version}
@@ -1050,18 +1132,27 @@ var publishCommand = new Command5("publish").description("Publish the current di
 - **Author:** ${manifest.author}
 
 Submitted via \`planmode publish\`.`
-      })
-    });
-    if (prRes.ok) {
-      const pr = await prRes.json();
-      logger.blank();
-      logger.success(`Published ${manifest.name}@${manifest.version}`);
-      logger.info(`PR: ${pr.html_url}`);
-    } else {
-      const err = await prRes.text();
-      logger.error(`Failed to create PR: ${err}`);
-      process.exit(1);
-    }
+    })
+  });
+  if (!prRes.ok) {
+    const err = await prRes.text();
+    throw new Error(`Failed to create PR: ${err}`);
+  }
+  const pr = await prRes.json();
+  logger.success(`Published ${manifest.name}@${manifest.version}`);
+  logger.info(`PR: ${pr.html_url}`);
+  return {
+    prUrl: pr.html_url,
+    packageName: manifest.name,
+    version: manifest.version
+  };
+}
+
+// src/commands/publish.ts
+var publishCommand = new Command5("publish").description("Publish the current directory as a package to the registry").action(async () => {
+  try {
+    logger.blank();
+    const result = await publishPackage();
     logger.blank();
   } catch (err) {
     logger.error(err.message);
@@ -1181,9 +1272,114 @@ var infoCommand = new Command8("info").description("Show detailed info about a p
 
 // src/commands/init.ts
 import { Command as Command9 } from "commander";
+
+// src/lib/init.ts
 import fs9 from "fs";
 import path9 from "path";
 import { stringify as stringify3 } from "yaml";
+
+// src/lib/templates.ts
+function getPlanTemplate(name) {
+  return `# ${name}
+
+## Prerequisites
+
+- List any tools, dependencies, or setup required before starting
+
+## Steps
+
+1. **Step one** \u2014 Description of what to do first
+2. **Step two** \u2014 Description of what to do next
+3. **Step three** \u2014 Description of the final step
+
+## Verification
+
+- [ ] Verify step one completed successfully
+- [ ] Verify step two completed successfully
+- [ ] Verify the final result works as expected
+`;
+}
+function getRuleTemplate(name) {
+  return `# ${name}
+
+## Code Style
+
+- Follow consistent naming conventions
+- Keep functions small and focused
+
+## Best Practices
+
+- Prefer composition over inheritance
+- Write self-documenting code
+
+## Avoid
+
+- Do not use deprecated APIs
+- Do not ignore error handling
+`;
+}
+function getPromptTemplate(name) {
+  return `# ${name}
+
+{{description}}
+
+## Context
+
+Provide any relevant context here.
+
+## Requirements
+
+- Requirement one
+- Requirement two
+
+## Output Format
+
+Describe the expected output format.
+`;
+}
+
+// src/lib/init.ts
+function createPackage(options) {
+  const {
+    name,
+    type,
+    description,
+    author,
+    license = "MIT",
+    tags = [],
+    category = "other",
+    projectDir = process.cwd()
+  } = options;
+  const manifest = {
+    name,
+    version: "1.0.0",
+    type,
+    description,
+    author,
+    license
+  };
+  if (tags.length > 0) manifest["tags"] = tags;
+  manifest["category"] = category;
+  const contentFile = `${type}.md`;
+  manifest["content_file"] = contentFile;
+  const yamlContent = stringify3(manifest);
+  const manifestPath = path9.join(projectDir, "planmode.yaml");
+  fs9.writeFileSync(manifestPath, yamlContent, "utf-8");
+  const stubs = {
+    plan: getPlanTemplate(name),
+    rule: getRuleTemplate(name),
+    prompt: getPromptTemplate(name)
+  };
+  const contentPath = path9.join(projectDir, contentFile);
+  fs9.writeFileSync(contentPath, stubs[type] ?? stubs["plan"], "utf-8");
+  return {
+    files: ["planmode.yaml", contentFile],
+    manifestPath,
+    contentPath
+  };
+}
+
+// src/commands/init.ts
 async function prompt(question) {
   const { createInterface } = await import("readline");
   const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -1211,46 +1407,23 @@ var initCommand = new Command9("init").description("Initialize a new package in
     const license = await prompt("License [MIT]: ") || "MIT";
     const tagsInput = await prompt("Tags (comma-separated): ");
     const tags = tagsInput ? tagsInput.split(",").map((t) => t.trim().toLowerCase()) : [];
-    const category = await prompt("Category (frontend/backend/devops/database/testing/mobile/ai-ml/security/other) [other]: ") || "other";
-    const manifest = {
+    const category = await prompt(
+      "Category (frontend/backend/devops/database/testing/mobile/ai-ml/security/other) [other]: "
+    ) || "other";
+    const result = createPackage({
       name,
-      version: "1.0.0",
       type,
       description,
       author,
-      license
-    };
-    if (tags.length > 0) manifest["tags"] = tags;
-    manifest["category"] = category;
-    const contentFile = `${type}.md`;
-    manifest["content_file"] = contentFile;
-    const yamlContent = stringify3(manifest);
-    fs9.writeFileSync(path9.join(process.cwd(), "planmode.yaml"), yamlContent, "utf-8");
-    logger.success("Created planmode.yaml");
-    const stubs = {
-      plan: `# ${name}
-
-1. First step
-2. Second step
-3. Third step
-`,
-      rule: `- Rule one
-- Rule two
-- Rule three
-`,
-      prompt: `Write your prompt here.
-
-Use {{variable_name}} for template variables.
-`
-    };
-    fs9.writeFileSync(
-      path9.join(process.cwd(), contentFile),
-      stubs[type] ?? stubs["plan"],
-      "utf-8"
-    );
-    logger.success(`Created ${contentFile}`);
+      license,
+      tags,
+      category
+    });
+    logger.success(`Created ${result.files.join(", ")}`);
     logger.blank();
-    logger.info(`Edit ${contentFile}, then run \`planmode publish\` when ready.`);
+    logger.info(
+      `Edit ${result.files[1]}, then run \`planmode publish\` when ready.`
+    );
     logger.blank();
   } catch (err) {
     logger.error(err.message);
@@ -1302,9 +1475,821 @@ var loginCommand = new Command10("login").description("Configure GitHub authenti
   logger.success(`Authenticated as ${user.login}`);
 });
 
+// src/commands/mcp.ts
+import { Command as Command11 } from "commander";
+import { execSync as execSync2 } from "child_process";
+var mcpCommand = new Command11("mcp").description("Manage MCP server registration with Claude Code");
+mcpCommand.command("setup").description("Register the planmode MCP server with Claude Code").action(() => {
+  try {
+    execSync2("claude mcp add --transport stdio planmode -- planmode-mcp", {
+      stdio: "inherit"
+    });
+    logger.success("Planmode MCP server registered with Claude Code.");
+    logger.dim("Claude Code can now use planmode tools directly.");
+  } catch (err) {
+    logger.error(
+      "Failed to register MCP server. Make sure Claude Code CLI is installed."
+    );
+    process.exit(1);
+  }
+});
+mcpCommand.command("remove").description("Remove the planmode MCP server from Claude Code").action(() => {
+  try {
+    execSync2("claude mcp remove planmode", { stdio: "inherit" });
+    logger.success("Planmode MCP server removed from Claude Code.");
+  } catch (err) {
+    logger.error(
+      "Failed to remove MCP server. Make sure Claude Code CLI is installed."
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/doctor.ts
+import { Command as Command12 } from "commander";
+
+// src/lib/doctor.ts
+import fs10 from "fs";
+import path10 from "path";
+import crypto2 from "crypto";
+function computeHash(content) {
+  return `sha256:${crypto2.createHash("sha256").update(content).digest("hex")}`;
+}
+function runDoctor(projectDir = process.cwd()) {
+  const issues = [];
+  const lockfile = readLockfile(projectDir);
+  const entries = Object.entries(lockfile.packages);
+  for (const [name, entry] of entries) {
+    const fullPath = path10.join(projectDir, entry.installed_to);
+    if (!fs10.existsSync(fullPath)) {
+      issues.push({
+        severity: "error",
+        message: `Missing file for "${name}": ${entry.installed_to}`,
+        fix: `Run \`planmode install ${name}\` to reinstall`
+      });
+      continue;
+    }
+    const content = fs10.readFileSync(fullPath, "utf-8");
+    const actualHash = computeHash(content);
+    if (actualHash !== entry.content_hash) {
+      issues.push({
+        severity: "warning",
+        message: `Content hash mismatch for "${name}" at ${entry.installed_to}`,
+        fix: "File was modified locally. Run `planmode update " + name + "` to restore, or ignore if intentional"
+      });
+    }
+  }
+  const claudeMdPath = path10.join(projectDir, "CLAUDE.md");
+  const imports = listImports(projectDir);
+  const installedPlans = entries.filter(([, entry]) => entry.type === "plan").map(([name]) => name);
+  for (const planName of installedPlans) {
+    if (!imports.includes(planName)) {
+      issues.push({
+        severity: "error",
+        message: `Plan "${planName}" is installed but missing from CLAUDE.md imports`,
+        fix: `Add \`- @plans/${planName}.md\` to the # Planmode section of CLAUDE.md`
+      });
+    }
+  }
+  for (const importName of imports) {
+    if (!installedPlans.includes(importName)) {
+      const filePath = path10.join(projectDir, "plans", `${importName}.md`);
+      if (!fs10.existsSync(filePath)) {
+        issues.push({
+          severity: "error",
+          message: `CLAUDE.md imports "${importName}" but the file doesn't exist at plans/${importName}.md`,
+          fix: `Run \`planmode install ${importName}\` or remove the import from CLAUDE.md`
+        });
+      } else {
+        issues.push({
+          severity: "warning",
+          message: `CLAUDE.md imports "${importName}" but it's not tracked in planmode.lock`,
+          fix: "This plan was added manually. No action needed unless you want lockfile tracking."
+        });
+      }
+    }
+  }
+  if (installedPlans.length > 0 && !fs10.existsSync(claudeMdPath)) {
+    issues.push({
+      severity: "error",
+      message: "CLAUDE.md is missing but plans are installed",
+      fix: "Run `planmode install <any-plan>` to recreate it, or create it manually with a # Planmode section"
+    });
+  }
+  const plansDir = path10.join(projectDir, "plans");
+  if (fs10.existsSync(plansDir)) {
+    const planFiles = fs10.readdirSync(plansDir).filter((f) => f.endsWith(".md"));
+    for (const file of planFiles) {
+      const name = file.replace(/\.md$/, "");
+      if (!lockfile.packages[name]) {
+        issues.push({
+          severity: "warning",
+          message: `Untracked plan file: plans/${file}`,
+          fix: "This file isn't managed by planmode. Ignore if intentional."
+        });
+      }
+    }
+  }
+  return {
+    issues,
+    packagesChecked: entries.length,
+    healthy: issues.filter((i) => i.severity === "error").length === 0
+  };
+}
+
+// src/commands/doctor.ts
+var doctorCommand = new Command12("doctor").description("Check project health: verify installed packages, imports, and file integrity").action(() => {
+  const result = runDoctor();
+  logger.blank();
+  logger.bold(`Checked ${result.packagesChecked} package(s)`);
+  logger.blank();
+  if (result.issues.length === 0) {
+    logger.success("Everything looks good. No issues found.");
+    logger.blank();
+    return;
+  }
+  const errors = result.issues.filter((i) => i.severity === "error");
+  const warnings = result.issues.filter((i) => i.severity === "warning");
+  for (const issue of errors) {
+    logger.error(issue.message);
+    if (issue.fix) logger.dim(`  Fix: ${issue.fix}`);
+  }
+  for (const issue of warnings) {
+    logger.warn(issue.message);
+    if (issue.fix) logger.dim(`  Fix: ${issue.fix}`);
+  }
+  logger.blank();
+  if (errors.length > 0) {
+    logger.error(`${errors.length} error(s), ${warnings.length} warning(s)`);
+  } else {
+    logger.warn(`${warnings.length} warning(s)`);
+  }
+  logger.blank();
+  if (errors.length > 0) {
+    process.exit(1);
+  }
+});
+
+// src/commands/test.ts
+import { Command as Command13 } from "commander";
+
+// src/lib/tester.ts
+async function testPackage(projectDir = process.cwd()) {
+  const issues = [];
+  const checks = [];
+  let manifest;
+  try {
+    manifest = readManifest(projectDir);
+    checks.push({ name: "Manifest parses", passed: true });
+  } catch (err) {
+    issues.push({
+      severity: "error",
+      check: "Manifest parses",
+      message: err.message
+    });
+    checks.push({ name: "Manifest parses", passed: false });
+    return { issues, passed: false, checks };
+  }
+  const errors = validateManifest(manifest, true);
+  if (errors.length === 0) {
+    checks.push({ name: "Manifest valid for publishing", passed: true });
+  } else {
+    for (const err of errors) {
+      issues.push({
+        severity: "error",
+        check: "Manifest valid for publishing",
+        message: err
+      });
+    }
+    checks.push({ name: "Manifest valid for publishing", passed: false });
+  }
+  let content;
+  try {
+    content = readPackageContent(projectDir, manifest);
+    if (content.trim().length === 0) {
+      issues.push({
+        severity: "warning",
+        check: "Content is non-empty",
+        message: "Content file is empty"
+      });
+      checks.push({ name: "Content is non-empty", passed: false });
+    } else {
+      checks.push({ name: "Content is non-empty", passed: true });
+    }
+  } catch (err) {
+    issues.push({
+      severity: "error",
+      check: "Content readable",
+      message: err.message
+    });
+    checks.push({ name: "Content readable", passed: false });
+  }
+  if (content && manifest.variables && Object.keys(manifest.variables).length > 0) {
+    try {
+      const missingDefaults = [];
+      for (const [name, def] of Object.entries(manifest.variables)) {
+        if (def.required && def.default === void 0) {
+          missingDefaults.push(name);
+        }
+      }
+      if (missingDefaults.length > 0) {
+        issues.push({
+          severity: "warning",
+          check: "Required variables have defaults",
+          message: `Required variables without defaults: ${missingDefaults.join(", ")}. Users must provide these at install time.`
+        });
+        checks.push({ name: "Required variables have defaults", passed: false });
+      } else {
+        checks.push({ name: "Required variables have defaults", passed: true });
+      }
+      const values = collectVariableValues(manifest.variables, {});
+      renderTemplate(content, values);
+      checks.push({ name: "Template renders with defaults", passed: true });
+    } catch (err) {
+      issues.push({
+        severity: "error",
+        check: "Template renders with defaults",
+        message: err.message
+      });
+      checks.push({ name: "Template renders with defaults", passed: false });
+    }
+  }
+  if (manifest.dependencies) {
+    const allDeps = [
+      ...manifest.dependencies.rules ?? [],
+      ...manifest.dependencies.plans ?? []
+    ];
+    for (const dep of allDeps) {
+      const depName = dep.includes("@") ? dep.split("@")[0] : dep;
+      try {
+        const results = await searchPackages(depName);
+        const found = results.some((r) => r.name === depName);
+        if (found) {
+          checks.push({ name: `Dependency "${depName}" exists`, passed: true });
+        } else {
+          issues.push({
+            severity: "warning",
+            check: `Dependency "${depName}" exists`,
+            message: `Dependency "${depName}" not found in registry. It may not be published yet.`
+          });
+          checks.push({ name: `Dependency "${depName}" exists`, passed: false });
+        }
+      } catch {
+        issues.push({
+          severity: "warning",
+          check: `Dependency "${depName}" exists`,
+          message: `Could not check registry for "${depName}" (network error)`
+        });
+        checks.push({ name: `Dependency "${depName}" exists`, passed: false });
+      }
+    }
+  }
+  if (content) {
+    const sizeKb = Buffer.byteLength(content, "utf-8") / 1024;
+    if (sizeKb > 100) {
+      issues.push({
+        severity: "warning",
+        check: "Content size reasonable",
+        message: `Content is ${sizeKb.toFixed(1)}KB. Large packages may hit token limits in AI models.`
+      });
+      checks.push({ name: "Content size reasonable", passed: false });
+    } else {
+      checks.push({ name: "Content size reasonable", passed: true });
+    }
+  }
+  const hasErrors = issues.some((i) => i.severity === "error");
+  return { issues, passed: !hasErrors, checks };
+}
+
+// src/commands/test.ts
+var testCommand = new Command13("test").description("Test the current package before publishing: validate manifest, render templates, check dependencies").action(async () => {
+  try {
+    logger.blank();
+    logger.bold("Testing package...");
+    logger.blank();
+    const result = await testPackage();
+    for (const check of result.checks) {
+      if (check.passed) {
+        logger.success(check.name);
+      } else {
+        const issue = result.issues.find((i) => i.check === check.name);
+        if (issue?.severity === "error") {
+          logger.error(`${check.name}: ${issue.message}`);
+        } else if (issue) {
+          logger.warn(`${check.name}: ${issue.message}`);
+        }
+      }
+    }
+    logger.blank();
+    if (result.passed) {
+      logger.success(`All checks passed. Ready to publish.`);
+    } else {
+      const errors = result.issues.filter((i) => i.severity === "error");
+      const warnings = result.issues.filter((i) => i.severity === "warning");
+      logger.error(`${errors.length} error(s), ${warnings.length} warning(s). Fix errors before publishing.`);
+    }
+    logger.blank();
+    if (!result.passed) {
+      process.exit(1);
+    }
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/record.ts
+import { Command as Command14 } from "commander";
+import fs12 from "fs";
+import path12 from "path";
+
+// src/lib/recorder.ts
+import fs11 from "fs";
+import path11 from "path";
+import { simpleGit as simpleGit2 } from "simple-git";
+import { stringify as stringify4 } from "yaml";
+var RECORDING_FILE = ".planmode-recording";
+function startRecording(projectDir = process.cwd()) {
+  const git = simpleGit2(projectDir);
+  const recordingPath = path11.join(projectDir, RECORDING_FILE);
+  if (fs11.existsSync(recordingPath)) {
+    const existing = fs11.readFileSync(recordingPath, "utf-8").trim();
+    throw new Error(
+      `Recording already in progress (started at ${existing}). Run \`planmode record stop\` first.`
+    );
+  }
+  return recordingPath;
+}
+async function startRecordingAsync(projectDir = process.cwd()) {
+  const recordingPath = startRecording(projectDir);
+  const git = simpleGit2(projectDir);
+  const log = await git.log({ n: 1 });
+  const sha = log.latest?.hash;
+  if (!sha) {
+    throw new Error("No commits found in this repository.");
+  }
+  fs11.writeFileSync(recordingPath, sha, "utf-8");
+  return sha;
+}
+function isRecording(projectDir = process.cwd()) {
+  return fs11.existsSync(path11.join(projectDir, RECORDING_FILE));
+}
+async function stopRecording(projectDir = process.cwd(), options = {}) {
+  const recordingPath = path11.join(projectDir, RECORDING_FILE);
+  if (!fs11.existsSync(recordingPath)) {
+    throw new Error("No recording in progress. Run `planmode record start` first.");
+  }
+  const startSha = fs11.readFileSync(recordingPath, "utf-8").trim();
+  const git = simpleGit2(projectDir);
+  const log = await git.log({ from: startSha, to: "HEAD" });
+  if (log.total === 0) {
+    fs11.unlinkSync(recordingPath);
+    throw new Error("No commits since recording started. Nothing to capture.");
+  }
+  const commits = [...log.all].reverse();
+  const steps = [];
+  const allFilesChanged = /* @__PURE__ */ new Set();
+  for (const commit of commits) {
+    const diff = await git.diffSummary([`${commit.hash}~1`, commit.hash]).catch(
+      () => (
+        // First commit in range might not have a parent in range
+        git.diffSummary([startSha, commit.hash])
+      )
+    );
+    const filesChanged = diff.files.map((f) => f.file);
+    filesChanged.forEach((f) => allFilesChanged.add(f));
+    const firstLine = commit.message.split("\n")[0].trim();
+    const body = commit.message.split("\n").slice(1).join("\n").trim();
+    steps.push({
+      title: firstLine,
+      message: body || firstLine,
+      filesChanged,
+      sha: commit.hash.slice(0, 7)
+    });
+  }
+  const planName = options.name || inferPlanName(steps);
+  const planContent = generatePlanContent(planName, steps);
+  const manifestContent = generateManifest(planName, options.author || "");
+  fs11.unlinkSync(recordingPath);
+  return {
+    steps,
+    planContent,
+    manifestContent,
+    totalCommits: commits.length,
+    totalFilesChanged: allFilesChanged.size
+  };
+}
+function inferPlanName(steps) {
+  const words = steps.map((s) => s.title.toLowerCase()).join(" ").replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 2 && !["the", "and", "for", "add", "fix", "update", "set"].includes(w));
+  const counts = /* @__PURE__ */ new Map();
+  for (const word of words) {
+    counts.set(word, (counts.get(word) || 0) + 1);
+  }
+  const topWords = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([w]) => w);
+  return topWords.length > 0 ? topWords.join("-") + "-setup" : "recorded-plan";
+}
+function generatePlanContent(name, steps) {
+  const lines = [];
+  lines.push(`# ${name}`);
+  lines.push("");
+  lines.push("## Steps");
+  lines.push("");
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    lines.push(`### ${i + 1}. ${step.title}`);
+    lines.push("");
+    if (step.message !== step.title) {
+      lines.push(step.message);
+      lines.push("");
+    }
+    if (step.filesChanged.length > 0) {
+      lines.push("**Files changed:**");
+      for (const file of step.filesChanged) {
+        lines.push(`- \`${file}\``);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("## Verification");
+  lines.push("");
+  lines.push("- [ ] All steps completed successfully");
+  lines.push("- [ ] Application builds without errors");
+  lines.push("- [ ] Tests pass");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateManifest(name, author) {
+  const manifest = {
+    name,
+    version: "1.0.0",
+    type: "plan",
+    description: `Plan recorded from git history`,
+    author: author || "unknown",
+    license: "MIT",
+    category: "other",
+    content_file: "plan.md"
+  };
+  return stringify4(manifest);
+}
+
+// src/commands/record.ts
+var recordCommand = new Command14("record").description("Record git activity and generate a plan from commits");
+recordCommand.command("start").description("Start recording \u2014 saves current HEAD as the starting point").action(async () => {
+  try {
+    logger.blank();
+    const sha = await startRecordingAsync();
+    logger.success(`Recording started at ${sha.slice(0, 7)}`);
+    logger.dim("Work normally. When done, run `planmode record stop` to generate a plan.");
+    logger.blank();
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+recordCommand.command("stop").description("Stop recording and generate a plan from commits since start").option("--name <name>", "Package name (auto-inferred if not provided)").option("--author <author>", "Author GitHub username").option("--dir <dir>", "Output directory for the generated package (default: current directory)").action(async (options) => {
+  try {
+    logger.blank();
+    logger.info("Analyzing commits...");
+    const result = await stopRecording(process.cwd(), {
+      name: options.name,
+      author: options.author
+    });
+    const outDir = options.dir ?? process.cwd();
+    fs12.mkdirSync(outDir, { recursive: true });
+    fs12.writeFileSync(path12.join(outDir, "planmode.yaml"), result.manifestContent, "utf-8");
+    fs12.writeFileSync(path12.join(outDir, "plan.md"), result.planContent, "utf-8");
+    logger.success(`Generated plan from ${result.totalCommits} commit(s) (${result.totalFilesChanged} files changed)`);
+    logger.blank();
+    for (let i = 0; i < result.steps.length; i++) {
+      const step = result.steps[i];
+      logger.dim(`  ${i + 1}. ${step.title} (${step.filesChanged.length} files)`);
+    }
+    logger.blank();
+    logger.success("Created planmode.yaml and plan.md");
+    logger.dim("Edit the generated plan, then run `planmode test` to validate and `planmode publish` when ready.");
+    logger.blank();
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+recordCommand.command("status").description("Check if a recording is in progress").action(() => {
+  if (isRecording()) {
+    logger.info("Recording is in progress. Run `planmode record stop` to generate a plan.");
+  } else {
+    logger.info("No recording in progress.");
+  }
+});
+
+// src/commands/snapshot.ts
+import { Command as Command15 } from "commander";
+import fs14 from "fs";
+import path14 from "path";
+
+// src/lib/snapshot.ts
+import fs13 from "fs";
+import path13 from "path";
+import { stringify as stringify5 } from "yaml";
+var CONFIG_FILES = {
+  "tsconfig.json": "TypeScript",
+  "tsconfig.base.json": "TypeScript (base)",
+  ".eslintrc": "ESLint",
+  ".eslintrc.js": "ESLint",
+  ".eslintrc.json": "ESLint",
+  "eslint.config.js": "ESLint (flat config)",
+  "eslint.config.mjs": "ESLint (flat config)",
+  ".prettierrc": "Prettier",
+  ".prettierrc.json": "Prettier",
+  "prettier.config.js": "Prettier",
+  "tailwind.config.js": "Tailwind CSS",
+  "tailwind.config.ts": "Tailwind CSS",
+  "tailwind.config.mjs": "Tailwind CSS",
+  "postcss.config.js": "PostCSS",
+  "postcss.config.mjs": "PostCSS",
+  "next.config.js": "Next.js",
+  "next.config.mjs": "Next.js",
+  "next.config.ts": "Next.js",
+  "vite.config.ts": "Vite",
+  "vite.config.js": "Vite",
+  "astro.config.mjs": "Astro",
+  "astro.config.ts": "Astro",
+  "svelte.config.js": "SvelteKit",
+  "nuxt.config.ts": "Nuxt",
+  "remix.config.js": "Remix",
+  "webpack.config.js": "Webpack",
+  "rollup.config.js": "Rollup",
+  "vitest.config.ts": "Vitest",
+  "jest.config.js": "Jest",
+  "jest.config.ts": "Jest",
+  "docker-compose.yml": "Docker Compose",
+  "docker-compose.yaml": "Docker Compose",
+  "Dockerfile": "Docker",
+  ".dockerignore": "Docker",
+  "prisma/schema.prisma": "Prisma",
+  "drizzle.config.ts": "Drizzle ORM",
+  ".env.example": "Environment variables",
+  ".github/workflows": "GitHub Actions",
+  "vercel.json": "Vercel",
+  "netlify.toml": "Netlify",
+  "wrangler.toml": "Cloudflare Workers",
+  "fly.toml": "Fly.io"
+};
+function takeSnapshot(projectDir = process.cwd(), options = {}) {
+  const data = analyzeProject(projectDir);
+  if (options.name) {
+    data.name = options.name;
+  }
+  const planContent = generatePlanFromSnapshot(data);
+  const manifestContent = generateManifestFromSnapshot(data, options.author || "");
+  return { planContent, manifestContent, data };
+}
+function analyzeProject(projectDir) {
+  let name = path13.basename(projectDir) + "-setup";
+  const dependencies = {};
+  const devDependencies = {};
+  const scripts = {};
+  const pkgPath = path13.join(projectDir, "package.json");
+  if (fs13.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
+      if (pkg.name) name = pkg.name + "-setup";
+      if (pkg.dependencies) Object.assign(dependencies, pkg.dependencies);
+      if (pkg.devDependencies) Object.assign(devDependencies, pkg.devDependencies);
+      if (pkg.scripts) Object.assign(scripts, pkg.scripts);
+    } catch {
+    }
+  }
+  const detectedTools = [];
+  for (const [file, toolName] of Object.entries(CONFIG_FILES)) {
+    const fullPath = path13.join(projectDir, file);
+    if (fs13.existsSync(fullPath)) {
+      detectedTools.push({ name: toolName, file });
+    }
+  }
+  const structure = getDirectoryStructure(projectDir, 2);
+  const framework = detectFramework(dependencies, devDependencies);
+  name = name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return { name, dependencies, devDependencies, detectedTools, structure, scripts, framework };
+}
+function detectFramework(deps, devDeps) {
+  const all = { ...deps, ...devDeps };
+  if (all["next"]) return "Next.js";
+  if (all["astro"]) return "Astro";
+  if (all["@sveltejs/kit"]) return "SvelteKit";
+  if (all["nuxt"]) return "Nuxt";
+  if (all["@remix-run/react"]) return "Remix";
+  if (all["vue"]) return "Vue";
+  if (all["react"]) return "React";
+  if (all["express"]) return "Express";
+  if (all["fastify"]) return "Fastify";
+  if (all["hono"]) return "Hono";
+  return null;
+}
+function getDirectoryStructure(dir, maxDepth, depth = 0) {
+  const SKIP = /* @__PURE__ */ new Set([
+    "node_modules",
+    "dist",
+    ".git",
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    ".astro",
+    ".vercel",
+    ".netlify",
+    "build",
+    "coverage",
+    "__pycache__",
+    ".turbo",
+    ".cache"
+  ]);
+  const results = [];
+  try {
+    const entries = fs13.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".github") continue;
+      if (SKIP.has(entry.name)) continue;
+      const indent = "  ".repeat(depth);
+      if (entry.isDirectory()) {
+        results.push(`${indent}${entry.name}/`);
+        if (depth < maxDepth) {
+          results.push(...getDirectoryStructure(path13.join(dir, entry.name), maxDepth, depth + 1));
+        }
+      } else {
+        results.push(`${indent}${entry.name}`);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function generatePlanFromSnapshot(data) {
+  const lines = [];
+  lines.push(`# ${data.name}`);
+  lines.push("");
+  if (data.framework) {
+    lines.push(`Set up a ${data.framework} project with the following tools and configuration.`);
+  } else {
+    lines.push("Set up a project with the following tools and configuration.");
+  }
+  lines.push("");
+  lines.push("## Prerequisites");
+  lines.push("");
+  lines.push("- Node.js 20+");
+  if (Object.keys(data.dependencies).length > 0 || Object.keys(data.devDependencies).length > 0) {
+    lines.push("- npm or your preferred package manager");
+  }
+  const toolNames = [...new Set(data.detectedTools.map((t) => t.name))];
+  if (toolNames.includes("Docker") || toolNames.includes("Docker Compose")) {
+    lines.push("- Docker");
+  }
+  if (toolNames.includes("Prisma")) {
+    lines.push("- A PostgreSQL database (or update the Prisma schema for your database)");
+  }
+  lines.push("");
+  lines.push("## Steps");
+  lines.push("");
+  let stepNum = 1;
+  if (data.framework) {
+    lines.push(`### ${stepNum}. Create ${data.framework} project`);
+    lines.push("");
+    lines.push(`Initialize a new ${data.framework} project.`);
+    lines.push("");
+    stepNum++;
+  }
+  const depNames = Object.keys(data.dependencies);
+  const devDepNames = Object.keys(data.devDependencies);
+  if (depNames.length > 0) {
+    lines.push(`### ${stepNum}. Install dependencies`);
+    lines.push("");
+    lines.push("```bash");
+    lines.push(`npm install ${depNames.join(" ")}`);
+    lines.push("```");
+    lines.push("");
+    stepNum++;
+  }
+  if (devDepNames.length > 0) {
+    lines.push(`### ${stepNum}. Install dev dependencies`);
+    lines.push("");
+    lines.push("```bash");
+    lines.push(`npm install -D ${devDepNames.join(" ")}`);
+    lines.push("```");
+    lines.push("");
+    stepNum++;
+  }
+  for (const tool of data.detectedTools) {
+    if (tool.name === data.framework) continue;
+    if (tool.name === "Environment variables") continue;
+    lines.push(`### ${stepNum}. Configure ${tool.name}`);
+    lines.push("");
+    lines.push(`Create or update \`${tool.file}\` with the appropriate configuration.`);
+    lines.push("");
+    stepNum++;
+  }
+  if (data.detectedTools.some((t) => t.name === "Environment variables")) {
+    lines.push(`### ${stepNum}. Set up environment variables`);
+    lines.push("");
+    lines.push("Copy `.env.example` to `.env` and fill in the values:");
+    lines.push("");
+    lines.push("```bash");
+    lines.push("cp .env.example .env");
+    lines.push("```");
+    lines.push("");
+    stepNum++;
+  }
+  if (Object.keys(data.scripts).length > 0) {
+    lines.push(`### ${stepNum}. Available scripts`);
+    lines.push("");
+    for (const [name, cmd] of Object.entries(data.scripts)) {
+      lines.push(`- \`npm run ${name}\` \u2014 \`${cmd}\``);
+    }
+    lines.push("");
+    stepNum++;
+  }
+  if (data.structure.length > 0) {
+    lines.push("## Project Structure");
+    lines.push("");
+    lines.push("```");
+    for (const line of data.structure.slice(0, 40)) {
+      lines.push(line);
+    }
+    if (data.structure.length > 40) {
+      lines.push("  ...");
+    }
+    lines.push("```");
+    lines.push("");
+  }
+  lines.push("## Verification");
+  lines.push("");
+  lines.push("- [ ] All dependencies installed without errors");
+  lines.push("- [ ] Configuration files are in place");
+  if (data.scripts["build"]) lines.push("- [ ] `npm run build` succeeds");
+  if (data.scripts["test"]) lines.push("- [ ] `npm run test` passes");
+  if (data.scripts["dev"]) lines.push("- [ ] `npm run dev` starts without errors");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateManifestFromSnapshot(data, author) {
+  const tags = [];
+  if (data.framework) tags.push(data.framework.toLowerCase().replace(/[^a-z0-9]/g, ""));
+  const toolTags = data.detectedTools.map((t) => t.name.toLowerCase().replace(/[^a-z0-9]/g, "-")).filter((t) => t.length > 1);
+  tags.push(...[...new Set(toolTags)].slice(0, 8));
+  const category = detectCategory(data);
+  const manifest = {
+    name: data.name,
+    version: "1.0.0",
+    type: "plan",
+    description: data.framework ? `Set up a ${data.framework} project with ${data.detectedTools.map((t) => t.name).slice(0, 3).join(", ")}` : `Project setup with ${data.detectedTools.map((t) => t.name).slice(0, 3).join(", ")}`,
+    author: author || "unknown",
+    license: "MIT",
+    tags: tags.slice(0, 10),
+    category,
+    content_file: "plan.md"
+  };
+  return stringify5(manifest);
+}
+function detectCategory(data) {
+  const all = { ...data.dependencies, ...data.devDependencies };
+  if (all["react"] || all["vue"] || all["svelte"] || all["next"] || all["astro"]) return "frontend";
+  if (all["express"] || all["fastify"] || all["hono"] || all["koa"]) return "backend";
+  if (data.detectedTools.some((t) => t.name === "Docker" || t.name === "Docker Compose")) return "devops";
+  if (all["prisma"] || all["drizzle-orm"] || all["typeorm"]) return "database";
+  return "other";
+}
+
+// src/commands/snapshot.ts
+var snapshotCommand = new Command15("snapshot").description("Analyze the current project and generate a plan that recreates this setup").option("--name <name>", "Package name (auto-inferred from project)").option("--author <author>", "Author GitHub username").option("--dir <dir>", "Output directory for the generated package (default: current directory)").action((options) => {
+  try {
+    logger.blank();
+    logger.info("Analyzing project...");
+    const result = takeSnapshot(process.cwd(), {
+      name: options.name,
+      author: options.author
+    });
+    const outDir = options.dir ?? process.cwd();
+    fs14.mkdirSync(outDir, { recursive: true });
+    fs14.writeFileSync(path14.join(outDir, "planmode.yaml"), result.manifestContent, "utf-8");
+    fs14.writeFileSync(path14.join(outDir, "plan.md"), result.planContent, "utf-8");
+    logger.blank();
+    logger.success(`Snapshot: ${result.data.name}`);
+    if (result.data.framework) {
+      logger.dim(`  Framework: ${result.data.framework}`);
+    }
+    logger.dim(`  Dependencies: ${Object.keys(result.data.dependencies).length}`);
+    logger.dim(`  Dev dependencies: ${Object.keys(result.data.devDependencies).length}`);
+    logger.dim(`  Tools detected: ${result.data.detectedTools.map((t) => t.name).join(", ") || "none"}`);
+    logger.blank();
+    logger.success("Created planmode.yaml and plan.md");
+    logger.dim("Edit the generated plan, then run `planmode test` to validate and `planmode publish` when ready.");
+    logger.blank();
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+
 // src/index.ts
-var program = new Command11();
-program.name("planmode").description("The open source package manager for AI plans, rules, and prompts.").version("0.1.5");
+var program = new Command16();
+program.name("planmode").description("The open source package manager for AI plans, rules, and prompts.").version("0.2.1");
 program.addCommand(installCommand);
 program.addCommand(uninstallCommand);
 program.addCommand(searchCommand);
@@ -1315,4 +2300,9 @@ program.addCommand(listCommand);
 program.addCommand(infoCommand);
 program.addCommand(initCommand);
 program.addCommand(loginCommand);
+program.addCommand(mcpCommand);
+program.addCommand(doctorCommand);
+program.addCommand(testCommand);
+program.addCommand(recordCommand);
+program.addCommand(snapshotCommand);
 program.parse();