planmode 0.2.2 → 0.3.0

package/dist/index.js

@@ -1,28 +1,19 @@
 #!/usr/bin/env node
-
-// src/index.ts
-import { Command as Command16 } from "commander";
-
-// src/commands/install.ts
-import { Command } from "commander";
-
-// src/lib/installer.ts
-import fs7 from "fs";
-import path7 from "path";
-import crypto from "crypto";
-
-// src/lib/registry.ts
-import fs2 from "fs";
-import path2 from "path";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/lib/config.ts
 import fs from "fs";
 import path from "path";
 import os from "os";
 import { parse, stringify } from "yaml";
-var CONFIG_DIR = path.join(os.homedir(), ".planmode");
-var CONFIG_PATH = path.join(CONFIG_DIR, "config");
-var CACHE_DIR = path.join(CONFIG_DIR, "cache");
 function getCacheDir() {
   const config = readConfig();
   return config.cache?.dir ?? CACHE_DIR;
@@ -61,9 +52,19 @@ function getRegistries() {
     ...config.registries
   };
 }
+var CONFIG_DIR, CONFIG_PATH, CACHE_DIR;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    CONFIG_DIR = path.join(os.homedir(), ".planmode");
+    CONFIG_PATH = path.join(CONFIG_DIR, "config");
+    CACHE_DIR = path.join(CONFIG_DIR, "cache");
+  }
+});
 
 // src/lib/registry.ts
-var INDEX_CACHE_FILE = "index.json";
+import fs2 from "fs";
+import path2 from "path";
 function getHeaders() {
   const headers = {
     "Accept": "application/vnd.github.v3.raw+json",
@@ -164,6 +165,14 @@ async function fetchVersionMetadata(packageName, version) {
   }
   return await response.json();
 }
+var INDEX_CACHE_FILE;
+var init_registry = __esm({
+  "src/lib/registry.ts"() {
+    "use strict";
+    init_config();
+    INDEX_CACHE_FILE = "index.json";
+  }
+});
 
 // src/lib/resolver.ts
 function parseSemver(version) {
@@ -245,6 +254,12 @@ async function resolveVersion(packageName, versionRange) {
   const version = matching[matching.length - 1];
   return { version, metadata };
 }
+var init_resolver = __esm({
+  "src/lib/resolver.ts"() {
+    "use strict";
+    init_registry();
+  }
+});
 
 // src/lib/git.ts
 import fs3 from "fs";
@@ -316,15 +331,20 @@ async function getRemoteUrl(dir) {
 }
 async function getHeadSha(dir) {
   const git = simpleGit(dir);
-  const log = await git.log({ n: 1 });
-  return log.latest?.hash ?? "";
+  const log8 = await git.log({ n: 1 });
+  return log8.latest?.hash ?? "";
 }
+var init_git = __esm({
+  "src/lib/git.ts"() {
+    "use strict";
+    init_config();
+  }
+});
 
 // src/lib/lockfile.ts
 import fs4 from "fs";
 import path4 from "path";
 import { parse as parse2, stringify as stringify2 } from "yaml";
-var LOCKFILE_NAME = "planmode.lock";
 function getLockfilePath(projectDir = process.cwd()) {
   return path4.join(projectDir, LOCKFILE_NAME);
 }
@@ -356,12 +376,17 @@ function getLockedVersion(packageName, projectDir = process.cwd()) {
   const lockfile = readLockfile(projectDir);
   return lockfile.packages[packageName];
 }
+var LOCKFILE_NAME;
+var init_lockfile = __esm({
+  "src/lib/lockfile.ts"() {
+    "use strict";
+    LOCKFILE_NAME = "planmode.lock";
+  }
+});
 
 // src/lib/claude-md.ts
 import fs5 from "fs";
 import path5 from "path";
-var CLAUDE_MD = "CLAUDE.md";
-var PLANMODE_SECTION = "# Planmode";
 function getClaudeMdPath(projectDir = process.cwd()) {
   return path5.join(projectDir, CLAUDE_MD);
 }
@@ -411,27 +436,19 @@ function listImports(projectDir = process.cwd()) {
   }
   return imports;
 }
+var CLAUDE_MD, PLANMODE_SECTION;
+var init_claude_md = __esm({
+  "src/lib/claude-md.ts"() {
+    "use strict";
+    CLAUDE_MD = "CLAUDE.md";
+    PLANMODE_SECTION = "# Planmode";
+  }
+});
 
 // src/lib/manifest.ts
 import fs6 from "fs";
 import path6 from "path";
 import { parse as parse3 } from "yaml";
-var NAME_REGEX = /^(@[a-z0-9-]+\/)?[a-z0-9][a-z0-9-]*$/;
-var SEMVER_REGEX = /^\d+\.\d+\.\d+$/;
-var VALID_TYPES = ["prompt", "rule", "plan"];
-var VALID_VAR_TYPES = ["string", "number", "boolean", "enum", "resolved"];
-var VALID_CATEGORIES = [
-  "frontend",
-  "backend",
-  "devops",
-  "database",
-  "testing",
-  "mobile",
-  "ai-ml",
-  "design",
-  "security",
-  "other"
-];
 function parseManifest(raw) {
   const data = parse3(raw);
   if (!data || typeof data !== "object") {
@@ -518,10 +535,31 @@ function readPackageContent(dir, manifest) {
   }
   throw new Error("Package must specify either content or content_file");
 }
+var NAME_REGEX, SEMVER_REGEX, VALID_TYPES, VALID_VAR_TYPES, VALID_CATEGORIES;
+var init_manifest = __esm({
+  "src/lib/manifest.ts"() {
+    "use strict";
+    NAME_REGEX = /^(@[a-z0-9-]+\/)?[a-z0-9][a-z0-9-]*$/;
+    SEMVER_REGEX = /^\d+\.\d+\.\d+$/;
+    VALID_TYPES = ["prompt", "rule", "plan"];
+    VALID_VAR_TYPES = ["string", "number", "boolean", "enum", "resolved"];
+    VALID_CATEGORIES = [
+      "frontend",
+      "backend",
+      "devops",
+      "database",
+      "testing",
+      "mobile",
+      "ai-ml",
+      "design",
+      "security",
+      "other"
+    ];
+  }
+});
 
 // src/lib/template.ts
 import Handlebars from "handlebars";
-Handlebars.registerHelper("eq", (a, b) => a === b);
 function renderTemplate(content, variables) {
   const template = Handlebars.compile(content);
   return template(variables);
@@ -584,118 +622,256 @@ function extractPath(obj, pathStr) {
   }
   return String(current ?? "");
 }
+var init_template = __esm({
+  "src/lib/template.ts"() {
+    "use strict";
+    Handlebars.registerHelper("eq", (a, b) => a === b);
+  }
+});
 
 // src/lib/logger.ts
-var RESET = "\x1B[0m";
-var RED = "\x1B[31m";
-var GREEN = "\x1B[32m";
-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 = [];
+var RESET, RED, GREEN, YELLOW, CYAN, DIM, BOLD, capturing, captured, logger;
+var init_logger = __esm({
+  "src/lib/logger.ts"() {
+    "use strict";
+    RESET = "\x1B[0m";
+    RED = "\x1B[31m";
+    GREEN = "\x1B[32m";
+    YELLOW = "\x1B[33m";
+    CYAN = "\x1B[36m";
+    DIM = "\x1B[2m";
+    BOLD = "\x1B[1m";
     capturing = false;
-    return messages;
-  },
-  isCapturing() {
-    return capturing;
-  },
-  info(msg) {
-    const text = `info ${msg}`;
-    if (capturing) {
-      captured.push(stripAnsi(text));
-    } else {
-      console.log(`${CYAN}info${RESET} ${msg}`);
-    }
-  },
-  success(msg) {
-    const text = `\u2713 ${msg}`;
-    if (capturing) {
-      captured.push(stripAnsi(text));
-    } else {
-      console.log(`${GREEN}\u2713${RESET} ${msg}`);
-    }
-  },
-  warn(msg) {
-    const text = `warn ${msg}`;
-    if (capturing) {
-      captured.push(stripAnsi(text));
-    } else {
-      console.log(`${YELLOW}warn${RESET} ${msg}`);
-    }
-  },
-  error(msg) {
-    const text = `error ${msg}`;
-    if (capturing) {
-      captured.push(stripAnsi(text));
-    } else {
-      console.error(`${RED}error${RESET} ${msg}`);
-    }
-  },
-  dim(msg) {
-    if (capturing) {
-      captured.push(msg);
-    } else {
-      console.log(`${DIM}${msg}${RESET}`);
-    }
-  },
-  bold(msg) {
-    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("  ");
-    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}`);
+    captured = [];
+    logger = {
+      capture() {
+        capturing = true;
+        captured = [];
+      },
+      flush() {
+        const messages = captured;
+        captured = [];
+        capturing = false;
+        return messages;
+      },
+      isCapturing() {
+        return capturing;
+      },
+      info(msg) {
+        const text4 = `info ${msg}`;
+        if (capturing) {
+          captured.push(stripAnsi(text4));
+        } else {
+          console.log(`${CYAN}info${RESET} ${msg}`);
+        }
+      },
+      success(msg) {
+        const text4 = `\u2713 ${msg}`;
+        if (capturing) {
+          captured.push(stripAnsi(text4));
+        } else {
+          console.log(`${GREEN}\u2713${RESET} ${msg}`);
+        }
+      },
+      warn(msg) {
+        const text4 = `warn ${msg}`;
+        if (capturing) {
+          captured.push(stripAnsi(text4));
+        } else {
+          console.log(`${YELLOW}warn${RESET} ${msg}`);
+        }
+      },
+      error(msg) {
+        const text4 = `error ${msg}`;
+        if (capturing) {
+          captured.push(stripAnsi(text4));
+        } else {
+          console.error(`${RED}error${RESET} ${msg}`);
+        }
+      },
+      dim(msg) {
+        if (capturing) {
+          captured.push(msg);
+        } else {
+          console.log(`${DIM}${msg}${RESET}`);
+        }
+      },
+      bold(msg) {
+        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("  ");
+        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() {
+        if (capturing) {
+          captured.push("");
+        } else {
+          console.log();
+        }
       }
-    }
-  },
-  blank() {
-    if (capturing) {
-      captured.push("");
-    } else {
-      console.log();
-    }
+    };
   }
-};
+});
 
 // src/lib/analytics.ts
-var API_BASE = "https://api.planmode.org";
 function trackDownload(packageName) {
   fetch(`${API_BASE}/downloads/${encodeURIComponent(packageName)}`, {
     method: "POST"
   }).catch(() => {
   });
 }
+var API_BASE;
+var init_analytics = __esm({
+  "src/lib/analytics.ts"() {
+    "use strict";
+    API_BASE = "https://api.planmode.org";
+  }
+});
+
+// src/lib/prompts.ts
+import * as p from "@clack/prompts";
+function isInteractive() {
+  return Boolean(process.stdin.isTTY) && !process.env.CI;
+}
+function handleCancel(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+async function promptForVariable(name, def) {
+  switch (def.type) {
+    case "enum": {
+      const value = await p.select({
+        message: def.description || name,
+        options: (def.options ?? []).map((opt) => ({
+          value: opt,
+          label: opt
+        })),
+        initialValue: def.default !== void 0 ? String(def.default) : void 0
+      });
+      return handleCancel(value);
+    }
+    case "boolean": {
+      const value = await p.confirm({
+        message: def.description || name,
+        initialValue: def.default !== void 0 ? Boolean(def.default) : false
+      });
+      return handleCancel(value);
+    }
+    case "number": {
+      const value = await p.text({
+        message: def.description || name,
+        placeholder: def.default !== void 0 ? String(def.default) : void 0,
+        defaultValue: def.default !== void 0 ? String(def.default) : void 0,
+        validate(input) {
+          if (isNaN(Number(input))) return "Must be a number";
+        }
+      });
+      return Number(handleCancel(value));
+    }
+    case "string":
+    default: {
+      const value = await p.text({
+        message: def.description || name,
+        placeholder: def.default !== void 0 ? String(def.default) : void 0,
+        defaultValue: def.default !== void 0 ? String(def.default) : void 0,
+        validate(input) {
+          if (def.required && !input) return `${name} is required`;
+        }
+      });
+      return handleCancel(value);
+    }
+  }
+}
+async function promptForVariables(variableDefs, provided, noInput = false) {
+  const values = {};
+  for (const [name, def] of Object.entries(variableDefs)) {
+    if (def.type === "resolved") continue;
+    if (provided[name] !== void 0) {
+      values[name] = coerceValue2(provided[name], def);
+    } else if (def.default !== void 0) {
+      if (isInteractive() && !noInput) {
+        values[name] = await promptForVariable(name, def);
+      } else {
+        values[name] = def.default;
+      }
+    } else if (def.required) {
+      if (isInteractive() && !noInput) {
+        values[name] = await promptForVariable(name, def);
+      } else {
+        throw new Error(`Missing required variable: ${name} -- ${def.description}`);
+      }
+    }
+  }
+  return values;
+}
+function coerceValue2(raw, def) {
+  switch (def.type) {
+    case "number":
+      return Number(raw);
+    case "boolean":
+      return raw === "true" || raw === "1" || raw === "yes";
+    case "enum":
+      if (def.options && !def.options.includes(raw)) {
+        throw new Error(
+          `Invalid value "${raw}" for enum variable. Options: ${def.options.join(", ")}`
+        );
+      }
+      return raw;
+    default:
+      return raw;
+  }
+}
+async function withSpinner(message, fn, successMessage) {
+  if (!isInteractive()) {
+    return fn();
+  }
+  const s = p.spinner();
+  s.start(message);
+  try {
+    const result = await fn();
+    s.stop(successMessage ?? message);
+    return result;
+  } catch (err) {
+    s.stop(`Failed: ${message}`);
+    throw err;
+  }
+}
+var init_prompts = __esm({
+  "src/lib/prompts.ts"() {
+    "use strict";
+  }
+});
 
 // src/lib/installer.ts
+import fs7 from "fs";
+import path7 from "path";
+import crypto from "crypto";
 function getInstallDir(type) {
   switch (type) {
     case "plan":
@@ -714,38 +890,60 @@ function contentHash(content) {
 }
 async function installPackage(packageName, options = {}) {
   const projectDir = options.projectDir ?? process.cwd();
+  const interactive = options.interactive ?? (isInteractive() && !options.noInput);
   const locked = getLockedVersion(packageName, projectDir);
   if (locked && !options.version) {
     logger.dim(`${packageName}@${locked.version} already installed`);
     return;
   }
-  logger.info(`Resolving ${packageName}...`);
-  const { version, metadata } = await resolveVersion(packageName, options.version);
-  const versionMeta = await fetchVersionMetadata(packageName, version);
-  logger.info(`Fetching ${packageName}@${version}...`);
-  const basePath = versionMeta.source.path ? `${versionMeta.source.path}/` : "";
-  const manifestRaw = await fetchFileAtTag(
-    versionMeta.source.repository,
-    versionMeta.source.tag,
-    `${basePath}planmode.yaml`
-  );
-  const manifest = parseManifest(manifestRaw);
-  let content;
-  if (manifest.content) {
-    content = manifest.content;
-  } else if (manifest.content_file) {
-    content = await fetchFileAtTag(
+  const resolveAndFetch = async () => {
+    const { version: version2, metadata: metadata2 } = await resolveVersion(packageName, options.version);
+    const versionMeta2 = await fetchVersionMetadata(packageName, version2);
+    return { version: version2, metadata: metadata2, versionMeta: versionMeta2 };
+  };
+  const { version, metadata, versionMeta } = interactive ? await withSpinner(
+    `Resolving ${packageName}...`,
+    resolveAndFetch,
+    `Resolved ${packageName}`
+  ) : await (async () => {
+    logger.info(`Resolving ${packageName}...`);
+    return resolveAndFetch();
+  })();
+  const fetchContent = async () => {
+    const basePath = versionMeta.source.path ? `${versionMeta.source.path}/` : "";
+    const manifestRaw = await fetchFileAtTag(
       versionMeta.source.repository,
       versionMeta.source.tag,
-      `${basePath}${manifest.content_file}`
+      `${basePath}planmode.yaml`
     );
-  } else {
-    throw new Error("Package has no content or content_file");
-  }
+    const manifest2 = parseManifest(manifestRaw);
+    let content2;
+    if (manifest2.content) {
+      content2 = manifest2.content;
+    } else if (manifest2.content_file) {
+      content2 = await fetchFileAtTag(
+        versionMeta.source.repository,
+        versionMeta.source.tag,
+        `${basePath}${manifest2.content_file}`
+      );
+    } else {
+      throw new Error("Package has no content or content_file");
+    }
+    return { manifest: manifest2, content: content2 };
+  };
+  const { manifest, content: rawContent } = interactive ? await withSpinner(
+    `Fetching ${packageName}@${version}...`,
+    fetchContent,
+    `Fetched ${packageName}@${version}`
+  ) : await (async () => {
+    logger.info(`Fetching ${packageName}@${version}...`);
+    return fetchContent();
+  })();
+  let content = rawContent;
   if (manifest.variables && Object.keys(manifest.variables).length > 0) {
     const provided = options.variables ?? {};
-    if (options.noInput) {
-      const values = collectVariableValues(manifest.variables, provided);
+    if (interactive) {
+      const values = await promptForVariables(manifest.variables, provided, false);
       content = renderTemplate(content, values);
     } else {
       const values = collectVariableValues(manifest.variables, provided);
@@ -807,7 +1005,8 @@ async function installPackage(packageName, options = {}) {
       await installPackage(name, {
         version: range === "*" ? void 0 : range,
         projectDir,
-        noInput: options.noInput
+        noInput: options.noInput,
+        interactive: options.interactive
       });
     }
   }
@@ -844,78 +1043,872 @@ async function updatePackage(packageName, projectDir = process.cwd()) {
   await installPackage(packageName, { version, projectDir });
   return true;
 }
-
-// src/commands/install.ts
-function parseVariables(pairs) {
-  const vars = {};
-  for (const pair of pairs) {
-    const eq = pair.indexOf("=");
-    if (eq === -1) {
-      throw new Error(`Invalid variable format: "${pair}". Use --set key=value`);
-    }
-    vars[pair.slice(0, eq)] = pair.slice(eq + 1);
+var init_installer = __esm({
+  "src/lib/installer.ts"() {
+    "use strict";
+    init_resolver();
+    init_registry();
+    init_git();
+    init_lockfile();
+    init_claude_md();
+    init_manifest();
+    init_template();
+    init_logger();
+    init_analytics();
+    init_prompts();
   }
-  return vars;
+});
+
+// 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
+`;
 }
-var installCommand = new Command("install").description("Install a package into the current project").argument("<package>", "Package name (e.g., nextjs-tailwind-starter)").option("-v, --version <version>", "Install specific version").option("--rule", "Force install as a rule to .claude/rules/").option("--no-input", "Fail if any required variable is missing").option("--set <key=value...>", "Set template variables (e.g., --set project_name=myapp)").action(
-  async (packageName, options) => {
-    try {
-      logger.blank();
-      const variables = options.set ? parseVariables(options.set) : void 0;
-      await installPackage(packageName, {
-        version: options.version,
-        forceRule: options.rule,
-        noInput: options.input === false,
-        variables
-      });
-      logger.blank();
-    } catch (err) {
-      logger.error(err.message);
-      process.exit(1);
-    }
-  }
-);
+function getRuleTemplate(name) {
+  return `# ${name}
 
-// src/commands/uninstall.ts
-import { Command as Command2 } from "commander";
-var uninstallCommand = new Command2("uninstall").description("Remove an installed package").argument("<package>", "Package name").action(async (packageName) => {
-  try {
-    logger.blank();
-    await uninstallPackage(packageName);
-    logger.blank();
-  } catch (err) {
-    logger.error(err.message);
-    process.exit(1);
+## 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.
+`;
+}
+var init_templates = __esm({
+  "src/lib/templates.ts"() {
+    "use strict";
   }
 });
 
-// src/commands/search.ts
-import { Command as Command3 } from "commander";
-var searchCommand = new Command3("search").description("Search the registry for packages").argument("<query>", "Search query").option("--type <type>", "Filter by type (prompt, rule, plan)").option("--category <category>", "Filter by category").option("--json", "Output as JSON").action(async (query, options) => {
-  try {
-    const results = await searchPackages(query, {
-      type: options.type,
-      category: options.category
-    });
-    if (results.length === 0) {
-      logger.info("No packages found matching your query.");
+// src/lib/init.ts
+import fs9 from "fs";
+import path9 from "path";
+import { stringify as stringify3 } from "yaml";
+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
+  };
+}
+var init_init = __esm({
+  "src/lib/init.ts"() {
+    "use strict";
+    init_templates();
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  initCommand: () => initCommand,
+  initInteractive: () => initInteractive
+});
+import { Command as Command9 } from "commander";
+import * as p6 from "@clack/prompts";
+async function initInteractive() {
+  p6.intro("Create a new planmode package");
+  const result = await p6.group(
+    {
+      name: () => p6.text({
+        message: "Package name",
+        placeholder: "my-awesome-plan",
+        validate(input) {
+          if (!input) return "Package name is required";
+          if (!/^[a-z0-9][a-z0-9-]*$/.test(input))
+            return "Lowercase letters, numbers, and hyphens only";
+        }
+      }),
+      type: () => p6.select({
+        message: "Package type",
+        options: [
+          { value: "plan", label: "Plan", hint: "multi-step implementation guide" },
+          { value: "rule", label: "Rule", hint: "always-on coding constraint" },
+          { value: "prompt", label: "Prompt", hint: "single-use templated prompt" }
+        ]
+      }),
+      description: () => p6.text({
+        message: "Description",
+        placeholder: "A short description of what this package does"
+      }),
+      author: () => p6.text({
+        message: "Author (GitHub username)",
+        placeholder: "username"
+      }),
+      license: () => p6.text({
+        message: "License",
+        defaultValue: "MIT",
+        placeholder: "MIT"
+      }),
+      category: () => p6.select({
+        message: "Category",
+        options: CATEGORIES.map((cat) => ({ value: cat, label: cat })),
+        initialValue: "other"
+      }),
+      tags: () => p6.text({
+        message: "Tags (comma-separated)",
+        placeholder: "nextjs, tailwind, starter"
+      })
+    },
+    {
+      onCancel() {
+        p6.cancel("Cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  const tags = result.tags ? result.tags.split(",").map((t) => t.trim().toLowerCase()).filter(Boolean) : [];
+  const output = createPackage({
+    name: result.name,
+    type: result.type,
+    description: result.description ?? "",
+    author: result.author ?? "",
+    license: result.license || "MIT",
+    tags,
+    category: result.category
+  });
+  p6.log.success(`Created ${output.files.join(", ")}`);
+  p6.outro(`Edit ${output.files[1]}, then run \`planmode publish\` when ready.`);
+}
+var CATEGORIES, initCommand;
+var init_init2 = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    init_logger();
+    init_init();
+    init_prompts();
+    CATEGORIES = [
+      "frontend",
+      "backend",
+      "devops",
+      "database",
+      "testing",
+      "mobile",
+      "ai-ml",
+      "design",
+      "security",
+      "other"
+    ];
+    initCommand = new Command9("init").description("Initialize a new package in the current directory").action(async () => {
+      try {
+        if (isInteractive()) {
+          await initInteractive();
+        } else {
+          logger.error("Interactive terminal required for `planmode init`. Use a TTY.");
+          process.exit(1);
+        }
+      } catch (err) {
+        logger.error(err.message);
+        process.exit(1);
+      }
+    });
+  }
+});
+
+// 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
+  };
+}
+var init_doctor = __esm({
+  "src/lib/doctor.ts"() {
+    "use strict";
+    init_lockfile();
+    init_claude_md();
+  }
+});
+
+// src/commands/interactive.ts
+var interactive_exports = {};
+__export(interactive_exports, {
+  runInteractiveMenu: () => runInteractiveMenu
+});
+import fs15 from "fs";
+import path15 from "path";
+import os3 from "os";
+import * as p12 from "@clack/prompts";
+function isFirstRun() {
+  const configPath = path15.join(os3.homedir(), ".planmode", "config");
+  const hasConfig = fs15.existsSync(configPath);
+  const lockfile = readLockfile();
+  const hasPackages = Object.keys(lockfile.packages).length > 0;
+  return !hasConfig && !hasPackages;
+}
+async function runInteractiveMenu() {
+  if (isFirstRun()) {
+    await firstRunFlow();
+  } else {
+    await mainMenu();
+  }
+}
+async function firstRunFlow() {
+  p12.intro("planmode");
+  p12.note(
+    [
+      "planmode installs AI plans, rules, and prompts into your project.",
+      "Plans work with Claude Code automatically via CLAUDE.md imports.",
+      "",
+      "  Plans   - step-by-step guides Claude follows to build things",
+      "  Rules   - always-on constraints that shape every AI interaction",
+      "  Prompts - reusable templates you run once to get output"
+    ].join("\n"),
+    "Welcome"
+  );
+  const action = handleCancel(
+    await p12.select({
+      message: "Let's get you started. What would you like to do?",
+      options: [
+        { value: "browse", label: "Browse popular packages", hint: "see what's available" },
+        { value: "search", label: "Search for something specific" },
+        { value: "create", label: "Create your own package", hint: "start from scratch" }
+      ]
+    })
+  );
+  switch (action) {
+    case "browse":
+      await featuredFlow();
+      break;
+    case "search":
+      await searchFlow();
+      break;
+    case "create": {
+      const { initInteractive: initInteractive2 } = await Promise.resolve().then(() => (init_init2(), init_exports));
+      await initInteractive2();
+      break;
+    }
+  }
+  const cont = handleCancel(
+    await p12.confirm({
+      message: "Continue exploring?",
+      initialValue: true
+    })
+  );
+  if (cont) {
+    await mainMenu();
+  } else {
+    p12.outro("Run `planmode` anytime to come back.");
+  }
+}
+async function featuredFlow() {
+  const index = await withSpinner(
+    "Loading packages...",
+    () => fetchIndex()
+  );
+  const plans = index.packages.filter((pkg) => pkg.type === "plan");
+  const rules = index.packages.filter((pkg) => pkg.type === "rule");
+  const prompts = index.packages.filter((pkg) => pkg.type === "prompt");
+  const featured = [
+    ...plans.slice(0, 5),
+    ...rules.slice(0, 3),
+    ...prompts.slice(0, 3)
+  ];
+  if (featured.length === 0) {
+    p12.log.warn("No packages in the registry yet.");
+    return;
+  }
+  const planOptions = plans.slice(0, 5).map((pkg) => ({
+    value: pkg.name,
+    label: pkg.name,
+    hint: pkg.description.length > 55 ? pkg.description.slice(0, 55) + "..." : pkg.description
+  }));
+  const ruleOptions = rules.slice(0, 3).map((pkg) => ({
+    value: pkg.name,
+    label: pkg.name,
+    hint: pkg.description.length > 55 ? pkg.description.slice(0, 55) + "..." : pkg.description
+  }));
+  const promptOptions = prompts.slice(0, 3).map((pkg) => ({
+    value: pkg.name,
+    label: pkg.name,
+    hint: pkg.description.length > 55 ? pkg.description.slice(0, 55) + "..." : pkg.description
+  }));
+  const allOptions = [];
+  if (planOptions.length > 0) {
+    allOptions.push(...planOptions);
+  }
+  if (ruleOptions.length > 0) {
+    allOptions.push(...ruleOptions);
+  }
+  if (promptOptions.length > 0) {
+    allOptions.push(...promptOptions);
+  }
+  const selected = handleCancel(
+    await p12.select({
+      message: `${index.packages.length} packages available. Pick one to install:`,
+      options: [
+        ...allOptions,
+        { value: "__more__", label: "Browse by category..." }
+      ]
+    })
+  );
+  if (selected === "__more__") {
+    await browseFlow();
+    return;
+  }
+  await installOrDetailFlow(selected);
+}
+async function mainMenu() {
+  p12.intro("planmode");
+  while (true) {
+    const action = handleCancel(
+      await p12.select({
+        message: "What would you like to do?",
+        options: [
+          { value: "search", label: "Search packages", hint: "find packages by keyword" },
+          { value: "browse", label: "Browse by category" },
+          { value: "install", label: "Install a package", hint: "install by name" },
+          { value: "create", label: "Create a new package" },
+          { value: "list", label: "My installed packages" },
+          { value: "doctor", label: "Health check" },
+          { value: "exit", label: "Exit" }
+        ]
+      })
+    );
+    switch (action) {
+      case "search":
+        await searchFlow();
+        break;
+      case "browse":
+        await browseFlow();
+        break;
+      case "install":
+        await installFlow();
+        break;
+      case "create": {
+        const { initInteractive: initInteractive2 } = await Promise.resolve().then(() => (init_init2(), init_exports));
+        await initInteractive2();
+        break;
+      }
+      case "list":
+        listFlow();
+        break;
+      case "doctor":
+        doctorFlow();
+        break;
+      case "exit":
+        p12.outro("Goodbye!");
+        return;
+    }
+  }
+}
+async function searchFlow() {
+  const query = handleCancel(
+    await p12.text({
+      message: "Search for packages:",
+      placeholder: "e.g. nextjs, tailwind, auth",
+      validate(input) {
+        if (!input) return "Please enter a search query";
+      }
+    })
+  );
+  const results = await withSpinner(
+    "Searching registry...",
+    () => searchPackages(query)
+  );
+  if (results.length === 0) {
+    p12.log.warn("No packages found matching your query.");
+    return;
+  }
+  p12.log.info(`Found ${results.length} package(s)`);
+  await packageSelectionFlow(results.map((r) => ({
+    name: r.name,
+    type: r.type,
+    version: r.version,
+    description: r.description
+  })));
+}
+async function browseFlow() {
+  const category = handleCancel(
+    await p12.select({
+      message: "Select a category:",
+      options: CATEGORIES2.map((cat) => ({
+        value: cat,
+        label: cat
+      }))
+    })
+  );
+  const results = await withSpinner(
+    `Loading ${category} packages...`,
+    () => searchPackages("", { category })
+  );
+  if (results.length === 0) {
+    p12.log.warn(`No packages found in category "${category}".`);
+    return;
+  }
+  p12.log.info(`Found ${results.length} package(s) in "${category}"`);
+  await packageSelectionFlow(results.map((r) => ({
+    name: r.name,
+    type: r.type,
+    version: r.version,
+    description: r.description
+  })));
+}
+async function packageSelectionFlow(packages) {
+  const selected = handleCancel(
+    await p12.select({
+      message: "Select a package:",
+      options: [
+        ...packages.map((pkg) => ({
+          value: pkg.name,
+          label: `${pkg.name} (${pkg.type} v${pkg.version})`,
+          hint: pkg.description.length > 60 ? pkg.description.slice(0, 60) + "..." : pkg.description
+        })),
+        { value: "__back__", label: "Back" }
+      ]
+    })
+  );
+  if (selected === "__back__") return;
+  await installOrDetailFlow(selected);
+}
+async function installOrDetailFlow(packageName) {
+  const action = handleCancel(
+    await p12.select({
+      message: `${packageName}:`,
+      options: [
+        { value: "install", label: "Install" },
+        { value: "details", label: "View details" },
+        { value: "back", label: "Back" }
+      ]
+    })
+  );
+  if (action === "install") {
+    try {
+      await installPackage(packageName, { interactive: true });
+      p12.log.success(`Installed ${packageName}`);
+    } catch (err) {
+      p12.log.error(err.message);
+    }
+  } else if (action === "details") {
+    try {
+      const meta = await withSpinner(
+        "Fetching package details...",
+        () => fetchPackageMetadata(packageName)
+      );
+      const lines = [
+        `Type:        ${meta.type}`,
+        `Author:      ${meta.author}`,
+        `License:     ${meta.license}`,
+        `Category:    ${meta.category}`,
+        `Downloads:   ${meta.downloads.toLocaleString()}`,
+        `Versions:    ${meta.versions.join(", ")}`,
+        `Repository:  ${meta.repository}`
+      ];
+      if (meta.tags?.length) {
+        lines.push(`Tags:        ${meta.tags.join(", ")}`);
+      }
+      if (meta.dependencies?.rules?.length) {
+        lines.push(`Dep (rules): ${meta.dependencies.rules.join(", ")}`);
+      }
+      if (meta.dependencies?.plans?.length) {
+        lines.push(`Dep (plans): ${meta.dependencies.plans.join(", ")}`);
+      }
+      p12.note(lines.join("\n"), `${meta.name}@${meta.latest_version}`);
+      const nextAction = handleCancel(
+        await p12.confirm({
+          message: "Install this package?",
+          initialValue: true
+        })
+      );
+      if (nextAction) {
+        try {
+          await installPackage(packageName, { interactive: true });
+          p12.log.success(`Installed ${packageName}`);
+        } catch (err) {
+          p12.log.error(err.message);
+        }
+      }
+    } catch (err) {
+      p12.log.error(err.message);
+    }
+  }
+}
+async function installFlow() {
+  const packageName = handleCancel(
+    await p12.text({
+      message: "Package name to install:",
+      placeholder: "e.g. nextjs-tailwind-starter",
+      validate(input) {
+        if (!input) return "Please enter a package name";
+      }
+    })
+  );
+  try {
+    await installPackage(packageName, { interactive: true });
+    p12.log.success(`Installed ${packageName}`);
+  } catch (err) {
+    p12.log.error(err.message);
+  }
+}
+function listFlow() {
+  const lockfile = readLockfile();
+  const entries = Object.entries(lockfile.packages);
+  if (entries.length === 0) {
+    p12.log.info('No packages installed. Select "Install a package" to get started.');
+    return;
+  }
+  const lines = entries.map(
+    ([name, entry]) => `${name} (${entry.type} v${entry.version}) -> ${entry.installed_to}`
+  );
+  p12.note(lines.join("\n"), "Installed packages");
+}
+function doctorFlow() {
+  const result = runDoctor();
+  if (result.issues.length === 0) {
+    p12.log.success(`Checked ${result.packagesChecked} package(s) \u2014 no issues found.`);
+    return;
+  }
+  const errors = result.issues.filter((i) => i.severity === "error");
+  const warnings = result.issues.filter((i) => i.severity === "warning");
+  for (const issue of errors) {
+    p12.log.error(issue.message);
+  }
+  for (const issue of warnings) {
+    p12.log.warn(issue.message);
+  }
+  if (errors.length > 0) {
+    p12.log.error(`${errors.length} error(s), ${warnings.length} warning(s)`);
+  } else {
+    p12.log.warn(`${warnings.length} warning(s)`);
+  }
+}
+var CATEGORIES2;
+var init_interactive = __esm({
+  "src/commands/interactive.ts"() {
+    "use strict";
+    init_prompts();
+    init_registry();
+    init_installer();
+    init_lockfile();
+    init_doctor();
+    CATEGORIES2 = [
+      "frontend",
+      "backend",
+      "devops",
+      "database",
+      "testing",
+      "mobile",
+      "ai-ml",
+      "design",
+      "security",
+      "other"
+    ];
+  }
+});
+
+// src/index.ts
+import { Command as Command16 } from "commander";
+
+// src/commands/install.ts
+init_installer();
+init_logger();
+init_prompts();
+import { Command } from "commander";
+import * as p2 from "@clack/prompts";
+function parseVariables(pairs) {
+  const vars = {};
+  for (const pair of pairs) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) {
+      throw new Error(`Invalid variable format: "${pair}". Use --set key=value`);
+    }
+    vars[pair.slice(0, eq)] = pair.slice(eq + 1);
+  }
+  return vars;
+}
+var installCommand = new Command("install").description("Install a package into the current project").argument("<package>", "Package name (e.g., nextjs-tailwind-starter)").option("-v, --version <version>", "Install specific version").option("--rule", "Force install as a rule to .claude/rules/").option("--no-input", "Fail if any required variable is missing").option("--set <key=value...>", "Set template variables (e.g., --set project_name=myapp)").action(
+  async (packageName, options) => {
+    try {
+      const interactive = isInteractive() && options.input !== false;
+      const variables = options.set ? parseVariables(options.set) : void 0;
+      if (interactive) {
+        p2.intro(`Installing ${packageName}`);
+      } else {
+        logger.blank();
+      }
+      await installPackage(packageName, {
+        version: options.version,
+        forceRule: options.rule,
+        noInput: options.input === false,
+        variables,
+        interactive
+      });
+      if (interactive) {
+        p2.outro("Done!");
+      } else {
+        logger.blank();
+      }
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  }
+);
+
+// src/commands/uninstall.ts
+init_installer();
+init_logger();
+import { Command as Command2 } from "commander";
+var uninstallCommand = new Command2("uninstall").description("Remove an installed package").argument("<package>", "Package name").action(async (packageName) => {
+  try {
+    logger.blank();
+    await uninstallPackage(packageName);
+    logger.blank();
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/search.ts
+init_registry();
+init_installer();
+init_logger();
+init_prompts();
+import { Command as Command3 } from "commander";
+import * as p3 from "@clack/prompts";
+var searchCommand = new Command3("search").description("Search the registry for packages").argument("<query>", "Search query").option("--type <type>", "Filter by type (prompt, rule, plan)").option("--category <category>", "Filter by category").option("--json", "Output as JSON").action(async (query, options) => {
+  try {
+    const results = await withSpinner(
+      "Searching registry...",
+      () => searchPackages(query, {
+        type: options.type,
+        category: options.category
+      })
+    );
+    if (results.length === 0) {
+      if (isInteractive() && !options.json) {
+        p3.log.warn("No packages found matching your query.");
+      } else {
+        logger.info("No packages found matching your query.");
+      }
       return;
     }
     if (options.json) {
       console.log(JSON.stringify(results, null, 2));
       return;
     }
-    logger.blank();
-    logger.table(
-      ["name", "type", "version", "description"],
-      results.map((pkg) => [
-        pkg.name,
-        pkg.type,
-        pkg.version,
-        pkg.description.length > 50 ? pkg.description.slice(0, 50) + "..." : pkg.description
-      ])
+    if (!isInteractive()) {
+      logger.blank();
+      logger.table(
+        ["name", "type", "version", "description"],
+        results.map((pkg) => [
+          pkg.name,
+          pkg.type,
+          pkg.version,
+          pkg.description.length > 50 ? pkg.description.slice(0, 50) + "..." : pkg.description
+        ])
+      );
+      logger.blank();
+      return;
+    }
+    const selected = handleCancel(
+      await p3.select({
+        message: `Found ${results.length} package(s). Select one:`,
+        options: [
+          ...results.map((pkg) => ({
+            value: pkg.name,
+            label: `${pkg.name} (${pkg.type} v${pkg.version})`,
+            hint: pkg.description.length > 60 ? pkg.description.slice(0, 60) + "..." : pkg.description
+          })),
+          { value: "__none__", label: "Cancel" }
+        ]
+      })
     );
-    logger.blank();
+    if (selected === "__none__") return;
+    const action = handleCancel(
+      await p3.select({
+        message: `${selected}:`,
+        options: [
+          { value: "install", label: "Install" },
+          { value: "details", label: "View details" },
+          { value: "back", label: "Cancel" }
+        ]
+      })
+    );
+    if (action === "install") {
+      try {
+        await installPackage(selected, { interactive: true });
+        p3.log.success(`Installed ${selected}`);
+      } catch (err) {
+        p3.log.error(err.message);
+      }
+    } else if (action === "details") {
+      const meta = await withSpinner(
+        "Fetching package details...",
+        () => fetchPackageMetadata(selected)
+      );
+      const lines = [
+        `Type:        ${meta.type}`,
+        `Author:      ${meta.author}`,
+        `License:     ${meta.license}`,
+        `Category:    ${meta.category}`,
+        `Downloads:   ${meta.downloads.toLocaleString()}`,
+        `Versions:    ${meta.versions.join(", ")}`,
+        `Repository:  ${meta.repository}`
+      ];
+      if (meta.tags?.length) {
+        lines.push(`Tags:        ${meta.tags.join(", ")}`);
+      }
+      p3.note(lines.join("\n"), `${meta.name}@${meta.latest_version}`);
+    }
   } catch (err) {
     logger.error(err.message);
     process.exit(1);
@@ -923,6 +1916,10 @@ var searchCommand = new Command3("search").description("Search the registry for
 });
 
 // src/commands/run.ts
+init_manifest();
+init_template();
+init_logger();
+init_prompts();
 import { Command as Command4 } from "commander";
 import fs8 from "fs";
 import path8 from "path";
@@ -957,18 +1954,8 @@ var runCommand = new Command4("run").description("Run a templated prompt and out
       process.exit(1);
     }
     if (manifest?.variables && Object.keys(manifest.variables).length > 0) {
-      const values = {};
-      for (const [name, def] of Object.entries(manifest.variables)) {
-        if (def.type === "resolved") continue;
-        if (vars[name] !== void 0) {
-          values[name] = vars[name];
-        } else if (def.default !== void 0) {
-          values[name] = def.default;
-        } else if (def.required && options.input === false) {
-          logger.error(`Missing required variable: --${name}`);
-          process.exit(1);
-        }
-      }
+      const noInput = options.input === false;
+      const values = await promptForVariables(manifest.variables, vars, noInput);
       for (const [name, def] of Object.entries(manifest.variables)) {
         if (def.type !== "resolved") continue;
         values[name] = await resolveVariable(def, values);
@@ -988,143 +1975,161 @@ var runCommand = new Command4("run").description("Run a templated prompt and out
 
 // src/commands/publish.ts
 import { Command as Command5 } from "commander";
+import * as p4 from "@clack/prompts";
 
 // src/lib/publisher.ts
+init_manifest();
+init_config();
+init_git();
+init_logger();
+init_prompts();
 async function publishPackage(options = {}) {
   const cwd = options.projectDir ?? process.cwd();
+  const interactive = options.interactive ?? false;
   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:
+  const doValidate = async () => {
+    const manifest2 = readManifest(cwd);
+    const errors = validateManifest(manifest2, true);
+    if (errors.length > 0) {
+      throw new Error(`Invalid manifest:
 ${errors.map((e) => `  - ${e}`).join("\n")}`);
-  }
+    }
+    return manifest2;
+  };
+  const manifest = interactive ? await withSpinner("Validating manifest...", doValidate, "Manifest valid") : await (async () => {
+    logger.info("Reading planmode.yaml...");
+    return doValidate();
+  })();
   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 {
-    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"
+  const tag = `v${manifest.version}`;
+  const doTag = async () => {
+    try {
+      await createTag(cwd, tag);
+    } catch {
+    }
+    try {
+      await pushTag(cwd, tag);
+    } catch {
+    }
   };
-  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.");
+  if (interactive) {
+    await withSpinner(`Creating tag ${tag}...`, doTag, `Tag ${tag} ready`);
+  } else {
+    logger.info(`Creating tag ${tag}...`);
+    await doTag();
+    logger.success(`Pushed tag ${tag}`);
   }
-  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: {
+  const doSubmit = async () => {
+    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,
-        tag,
-        sha
+        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
       },
-      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",
+      null,
+      2
+    );
+    const versionContent = JSON.stringify(
+      {
+        version: manifest.version,
+        published_at: (/* @__PURE__ */ new Date()).toISOString(),
+        source: {
+          repository: repoPath,
+          tag,
+          sha
+        },
+        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({
-        message: `Add ${manifest.name}@${manifest.version}`,
-        content: Buffer.from(metadataContent).toString("base64"),
-        branch: branchName
+        ref: `refs/heads/${branchName}`,
+        sha: baseSha
       })
-    }
-  );
-  await fetch(
-    `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/versions/${manifest.version}.json`,
-    {
-      method: "PUT",
+    });
+    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",
       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",
-    headers,
-    body: JSON.stringify({
-      title: `Add ${manifest.name}@${manifest.version}`,
-      head: `${user.login}:${branchName}`,
-      base: "main",
-      body: `## New package: ${manifest.name}
+        title: `Add ${manifest.name}@${manifest.version}`,
+        head: `${user.login}:${branchName}`,
+        base: "main",
+        body: `## New package: ${manifest.name}
 
 - **Type:** ${manifest.type}
 - **Version:** ${manifest.version}
@@ -1132,28 +2137,51 @@ ${errors.map((e) => `  - ${e}`).join("\n")}`);
 - **Author:** ${manifest.author}
 
 Submitted via \`planmode publish\`.`
-    })
-  });
-  if (!prRes.ok) {
-    const err = await prRes.text();
-    throw new Error(`Failed to create PR: ${err}`);
+      })
+    });
+    if (!prRes.ok) {
+      const err = await prRes.text();
+      throw new Error(`Failed to create PR: ${err}`);
+    }
+    const pr = await prRes.json();
+    return pr.html_url;
+  };
+  let prUrl;
+  if (interactive) {
+    prUrl = await withSpinner(
+      "Submitting to registry...",
+      doSubmit,
+      "Submitted to registry"
+    );
+  } else {
+    logger.info("Submitting to registry...");
+    prUrl = await doSubmit();
+    logger.success(`Published ${manifest.name}@${manifest.version}`);
+    logger.info(`PR: ${prUrl}`);
   }
-  const pr = await prRes.json();
-  logger.success(`Published ${manifest.name}@${manifest.version}`);
-  logger.info(`PR: ${pr.html_url}`);
   return {
-    prUrl: pr.html_url,
+    prUrl,
     packageName: manifest.name,
     version: manifest.version
   };
 }
 
 // src/commands/publish.ts
+init_logger();
+init_prompts();
 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();
+    if (isInteractive()) {
+      p4.intro("Publishing package");
+    } else {
+      logger.blank();
+    }
+    const result = await publishPackage({ interactive: isInteractive() });
+    if (isInteractive()) {
+      p4.outro(`Published ${result.packageName}@${result.version} \u2014 PR: ${result.prUrl}`);
+    } else {
+      logger.blank();
+    }
   } catch (err) {
     logger.error(err.message);
     process.exit(1);
@@ -1161,269 +2189,150 @@ var publishCommand = new Command5("publish").description("Publish the current di
 });
 
 // src/commands/update.ts
+init_installer();
+init_lockfile();
+init_logger();
+init_prompts();
 import { Command as Command6 } from "commander";
+import * as p5 from "@clack/prompts";
 var updateCommand = new Command6("update").description("Update installed packages to latest compatible versions").argument("[package]", "Package name (omit to update all)").action(async (packageName) => {
   try {
-    logger.blank();
+    const interactive = isInteractive();
+    if (interactive) {
+      p5.intro("Updating packages");
+    } else {
+      logger.blank();
+    }
     if (packageName) {
-      const updated = await updatePackage(packageName);
+      const updated = interactive ? await withSpinner(
+        `Checking ${packageName} for updates...`,
+        () => updatePackage(packageName)
+      ) : await updatePackage(packageName);
       if (!updated) {
-        logger.info("Already up to date.");
+        if (interactive) {
+          p5.log.info("Already up to date.");
+        } else {
+          logger.info("Already up to date.");
+        }
       }
     } else {
       const lockfile = readLockfile();
       const names = Object.keys(lockfile.packages);
       if (names.length === 0) {
-        logger.info("No packages installed.");
+        if (interactive) {
+          p5.log.info("No packages installed.");
+        } else {
+          logger.info("No packages installed.");
+        }
+        if (interactive) p5.outro("Nothing to update.");
         return;
       }
-      let updatedCount = 0;
-      for (const name of names) {
-        try {
-          const updated = await updatePackage(name);
-          if (updated) updatedCount++;
-        } catch (err) {
-          logger.warn(`Failed to update ${name}: ${err.message}`);
+      const doUpdate = async () => {
+        let updatedCount2 = 0;
+        for (const name of names) {
+          try {
+            const updated = await updatePackage(name);
+            if (updated) updatedCount2++;
+          } catch (err) {
+            logger.warn(`Failed to update ${name}: ${err.message}`);
+          }
         }
-      }
+        return updatedCount2;
+      };
+      const updatedCount = interactive ? await withSpinner("Checking for updates...", doUpdate) : await doUpdate();
       if (updatedCount === 0) {
-        logger.info("All packages are up to date.");
+        if (interactive) {
+          p5.log.info("All packages are up to date.");
+        } else {
+          logger.info("All packages are up to date.");
+        }
       } else {
-        logger.success(`Updated ${updatedCount} package${updatedCount > 1 ? "s" : ""}.`);
-      }
-    }
-    logger.blank();
-  } catch (err) {
-    logger.error(err.message);
-    process.exit(1);
-  }
-});
-
-// src/commands/list.ts
-import { Command as Command7 } from "commander";
-var listCommand = new Command7("list").description("List all installed packages").action(() => {
-  const lockfile = readLockfile();
-  const entries = Object.entries(lockfile.packages);
-  if (entries.length === 0) {
-    logger.info("No packages installed. Run `planmode install <package>` to get started.");
-    return;
-  }
-  logger.blank();
-  logger.table(
-    ["name", "type", "version", "location"],
-    entries.map(([name, entry]) => [
-      name,
-      entry.type,
-      entry.version,
-      entry.installed_to
-    ])
-  );
-  logger.blank();
-});
-
-// src/commands/info.ts
-import { Command as Command8 } from "commander";
-var infoCommand = new Command8("info").description("Show detailed info about a package").argument("<package>", "Package name").action(async (packageName) => {
-  try {
-    const meta = await fetchPackageMetadata(packageName);
-    logger.blank();
-    logger.bold(`${meta.name}@${meta.latest_version}`);
-    logger.blank();
-    console.log(`  Description:  ${meta.description}`);
-    console.log(`  Type:         ${meta.type}`);
-    console.log(`  Author:       ${meta.author}`);
-    console.log(`  License:      ${meta.license}`);
-    console.log(`  Category:     ${meta.category}`);
-    console.log(`  Downloads:    ${meta.downloads.toLocaleString()}`);
-    console.log(`  Repository:   ${meta.repository}`);
-    if (meta.models && meta.models.length > 0) {
-      console.log(`  Models:       ${meta.models.join(", ")}`);
-    }
-    if (meta.tags && meta.tags.length > 0) {
-      console.log(`  Tags:         ${meta.tags.join(", ")}`);
-    }
-    console.log(`  Versions:     ${meta.versions.join(", ")}`);
-    if (meta.dependencies) {
-      if (meta.dependencies.rules && meta.dependencies.rules.length > 0) {
-        console.log(`  Dep (rules):  ${meta.dependencies.rules.join(", ")}`);
-      }
-      if (meta.dependencies.plans && meta.dependencies.plans.length > 0) {
-        console.log(`  Dep (plans):  ${meta.dependencies.plans.join(", ")}`);
-      }
-    }
-    if (meta.variables) {
-      logger.blank();
-      logger.bold("  Variables:");
-      for (const [name, def] of Object.entries(meta.variables)) {
-        const required = def.required ? " (required)" : "";
-        const defaultVal = def.default !== void 0 ? ` [default: ${def.default}]` : "";
-        console.log(`    ${name}: ${def.type}${required}${defaultVal} \u2014 ${def.description}`);
-        if (def.options) {
-          console.log(`      options: ${def.options.join(", ")}`);
+        if (interactive) {
+          p5.log.success(`Updated ${updatedCount} package${updatedCount > 1 ? "s" : ""}.`);
+        } else {
+          logger.success(`Updated ${updatedCount} package${updatedCount > 1 ? "s" : ""}.`);
         }
-      }
-    }
-    logger.blank();
-  } catch (err) {
-    logger.error(err.message);
-    process.exit(1);
-  }
-});
-
-// 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
-  };
-}
+      }
+    }
+    if (interactive) {
+      p5.outro("Done!");
+    } else {
+      logger.blank();
+    }
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
 
-// src/commands/init.ts
-async function prompt(question) {
-  const { createInterface } = await import("readline");
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-var initCommand = new Command9("init").description("Initialize a new package in the current directory").action(async () => {
+// src/commands/list.ts
+init_lockfile();
+init_logger();
+import { Command as Command7 } from "commander";
+var listCommand = new Command7("list").description("List all installed packages").action(() => {
+  const lockfile = readLockfile();
+  const entries = Object.entries(lockfile.packages);
+  if (entries.length === 0) {
+    logger.info("No packages installed. Run `planmode install <package>` to get started.");
+    return;
+  }
+  logger.blank();
+  logger.table(
+    ["name", "type", "version", "location"],
+    entries.map(([name, entry]) => [
+      name,
+      entry.type,
+      entry.version,
+      entry.installed_to
+    ])
+  );
+  logger.blank();
+});
+
+// src/commands/info.ts
+init_registry();
+init_logger();
+import { Command as Command8 } from "commander";
+var infoCommand = new Command8("info").description("Show detailed info about a package").argument("<package>", "Package name").action(async (packageName) => {
   try {
+    const meta = await fetchPackageMetadata(packageName);
     logger.blank();
-    logger.bold("Initialize a new Planmode package");
+    logger.bold(`${meta.name}@${meta.latest_version}`);
     logger.blank();
-    const name = await prompt("Package name: ");
-    if (!name) {
-      logger.error("Package name is required.");
-      process.exit(1);
+    console.log(`  Description:  ${meta.description}`);
+    console.log(`  Type:         ${meta.type}`);
+    console.log(`  Author:       ${meta.author}`);
+    console.log(`  License:      ${meta.license}`);
+    console.log(`  Category:     ${meta.category}`);
+    console.log(`  Downloads:    ${meta.downloads.toLocaleString()}`);
+    console.log(`  Repository:   ${meta.repository}`);
+    if (meta.models && meta.models.length > 0) {
+      console.log(`  Models:       ${meta.models.join(", ")}`);
+    }
+    if (meta.tags && meta.tags.length > 0) {
+      console.log(`  Tags:         ${meta.tags.join(", ")}`);
+    }
+    console.log(`  Versions:     ${meta.versions.join(", ")}`);
+    if (meta.dependencies) {
+      if (meta.dependencies.rules && meta.dependencies.rules.length > 0) {
+        console.log(`  Dep (rules):  ${meta.dependencies.rules.join(", ")}`);
+      }
+      if (meta.dependencies.plans && meta.dependencies.plans.length > 0) {
+        console.log(`  Dep (plans):  ${meta.dependencies.plans.join(", ")}`);
+      }
+    }
+    if (meta.variables) {
+      logger.blank();
+      logger.bold("  Variables:");
+      for (const [name, def] of Object.entries(meta.variables)) {
+        const required = def.required ? " (required)" : "";
+        const defaultVal = def.default !== void 0 ? ` [default: ${def.default}]` : "";
+        console.log(`    ${name}: ${def.type}${required}${defaultVal} \u2014 ${def.description}`);
+        if (def.options) {
+          console.log(`      options: ${def.options.join(", ")}`);
+        }
+      }
     }
-    const typeInput = await prompt("Type (plan/rule/prompt) [plan]: ");
-    const type = typeInput || "plan";
-    const description = await prompt("Description: ");
-    const author = await prompt("Author (GitHub username): ");
-    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 result = createPackage({
-      name,
-      type,
-      description,
-      author,
-      license,
-      tags,
-      category
-    });
-    logger.success(`Created ${result.files.join(", ")}`);
-    logger.blank();
-    logger.info(
-      `Edit ${result.files[1]}, then run \`planmode publish\` when ready.`
-    );
     logger.blank();
   } catch (err) {
     logger.error(err.message);
@@ -1431,8 +2340,15 @@ var initCommand = new Command9("init").description("Initialize a new package in
   }
 });
 
+// src/index.ts
+init_init2();
+
 // src/commands/login.ts
+init_config();
+init_logger();
+init_prompts();
 import { Command as Command10 } from "commander";
+import * as p7 from "@clack/prompts";
 import { execSync } from "child_process";
 var loginCommand = new Command10("login").description("Configure GitHub authentication").option("--token <token>", "GitHub personal access token").option("--gh", "Read token from GitHub CLI (gh auth token)").action(async (options) => {
   let token;
@@ -1445,37 +2361,61 @@ var loginCommand = new Command10("login").description("Configure GitHub authenti
       logger.error("Failed to read token from GitHub CLI. Make sure `gh` is installed and authenticated.");
       process.exit(1);
     }
-  } else {
-    const { createInterface } = await import("readline");
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    token = await new Promise((resolve) => {
-      rl.question("GitHub personal access token: ", (answer) => {
-        rl.close();
-        resolve(answer.trim());
-      });
+  } else if (isInteractive()) {
+    p7.intro("planmode login");
+    const value = await p7.password({
+      message: "GitHub personal access token:",
+      validate(input) {
+        if (!input) return "Token is required";
+      }
     });
+    token = handleCancel(value);
+  } else {
+    logger.error("No token provided. Use --token <token> or --gh.");
+    process.exit(1);
   }
   if (!token) {
     logger.error("No token provided.");
     process.exit(1);
   }
-  logger.info("Validating token...");
-  const response = await fetch("https://api.github.com/user", {
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "User-Agent": "planmode-cli"
+  const validateToken = async () => {
+    const response = await fetch("https://api.github.com/user", {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "User-Agent": "planmode-cli"
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Invalid token. GitHub API returned: " + response.status);
+    }
+    return await response.json();
+  };
+  try {
+    const user = await withSpinner(
+      "Validating token...",
+      validateToken,
+      "Token validated"
+    );
+    setGitHubToken(token);
+    if (isInteractive()) {
+      p7.log.success(`Authenticated as ${user.login}`);
+      p7.outro("You're all set!");
+    } else {
+      logger.success(`Authenticated as ${user.login}`);
+    }
+  } catch (err) {
+    if (isInteractive()) {
+      p7.log.error(err.message);
+      p7.outro("Authentication failed.");
+    } else {
+      logger.error(err.message);
     }
-  });
-  if (!response.ok) {
-    logger.error("Invalid token. GitHub API returned: " + response.status);
     process.exit(1);
   }
-  const user = await response.json();
-  setGitHubToken(token);
-  logger.success(`Authenticated as ${user.login}`);
 });
 
 // src/commands/mcp.ts
+init_logger();
 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");
@@ -1506,125 +2446,67 @@ mcpCommand.command("remove").description("Remove the planmode MCP server from Cl
 });
 
 // src/commands/doctor.ts
+init_doctor();
+init_logger();
+init_prompts();
 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
+import * as p8 from "@clack/prompts";
 var doctorCommand = new Command12("doctor").description("Check project health: verify installed packages, imports, and file integrity").action(() => {
+  const interactive = isInteractive();
   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.");
+  if (interactive) {
+    p8.intro("Health check");
+  } else {
     logger.blank();
+  }
+  if (interactive) {
+    p8.log.info(`Checked ${result.packagesChecked} package(s)`);
+  } else {
+    logger.bold(`Checked ${result.packagesChecked} package(s)`);
+    logger.blank();
+  }
+  if (result.issues.length === 0) {
+    if (interactive) {
+      p8.outro("Everything looks good. No issues found.");
+    } else {
+      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}`);
+    if (interactive) {
+      p8.log.error(issue.message);
+    } else {
+      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}`);
+    if (interactive) {
+      p8.log.warn(issue.message);
+    } else {
+      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)`);
+  if (interactive) {
+    if (errors.length > 0) {
+      p8.outro(`${errors.length} error(s), ${warnings.length} warning(s)`);
+    } else {
+      p8.outro(`${warnings.length} warning(s)`);
+    }
   } else {
-    logger.warn(`${warnings.length} warning(s)`);
+    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();
   }
-  logger.blank();
   if (errors.length > 0) {
     process.exit(1);
   }
@@ -1632,8 +2514,12 @@ var doctorCommand = new Command12("doctor").description("Check project health: v
 
 // src/commands/test.ts
 import { Command as Command13 } from "commander";
+import * as p9 from "@clack/prompts";
 
 // src/lib/tester.ts
+init_manifest();
+init_template();
+init_registry();
 async function testPackage(projectDir = process.cwd()) {
   const issues = [];
   const checks = [];
@@ -1762,33 +2648,62 @@ async function testPackage(projectDir = process.cwd()) {
 }
 
 // src/commands/test.ts
+init_logger();
+init_prompts();
 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 interactive = isInteractive();
+    if (interactive) {
+      p9.intro("Testing package");
+    } else {
+      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);
+        if (interactive) {
+          p9.log.success(check.name);
+        } else {
+          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}`);
+          if (interactive) {
+            p9.log.error(`${check.name}: ${issue.message}`);
+          } else {
+            logger.error(`${check.name}: ${issue.message}`);
+          }
         } else if (issue) {
-          logger.warn(`${check.name}: ${issue.message}`);
+          if (interactive) {
+            p9.log.warn(`${check.name}: ${issue.message}`);
+          } else {
+            logger.warn(`${check.name}: ${issue.message}`);
+          }
         }
       }
     }
-    logger.blank();
-    if (result.passed) {
-      logger.success(`All checks passed. Ready to publish.`);
+    if (interactive) {
+      if (result.passed) {
+        p9.outro("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");
+        p9.outro(`${errors.length} error(s), ${warnings.length} warning(s). Fix errors before publishing.`);
+      }
     } 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) {
+        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();
     }
-    logger.blank();
     if (!result.passed) {
       process.exit(1);
     }
@@ -1800,6 +2715,7 @@ var testCommand = new Command13("test").description("Test the current package be
 
 // src/commands/record.ts
 import { Command as Command14 } from "commander";
+import * as p10 from "@clack/prompts";
 import fs12 from "fs";
 import path12 from "path";
 
@@ -1823,8 +2739,8 @@ function startRecording(projectDir = process.cwd()) {
 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;
+  const log8 = await git.log({ n: 1 });
+  const sha = log8.latest?.hash;
   if (!sha) {
     throw new Error("No commits found in this repository.");
   }
@@ -1841,12 +2757,12 @@ async function stopRecording(projectDir = process.cwd(), options = {}) {
   }
   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) {
+  const log8 = await git.log({ from: startSha, to: "HEAD" });
+  if (log8.total === 0) {
     fs11.unlinkSync(recordingPath);
     throw new Error("No commits since recording started. Nothing to capture.");
   }
-  const commits = [...log.all].reverse();
+  const commits = [...log8.all].reverse();
   const steps = [];
   const allFilesChanged = /* @__PURE__ */ new Set();
   for (const commit of commits) {
@@ -1933,6 +2849,8 @@ function generateManifest(name, author) {
 }
 
 // src/commands/record.ts
+init_logger();
+init_prompts();
 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 {
@@ -1948,12 +2866,26 @@ recordCommand.command("start").description("Start recording \u2014 saves current
 });
 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 interactive = isInteractive();
+    if (interactive) {
+      p10.intro("Generating plan from recording");
+    } else {
+      logger.blank();
+    }
+    const result = interactive ? await withSpinner(
+      "Analyzing commits...",
+      () => stopRecording(process.cwd(), {
+        name: options.name,
+        author: options.author
+      }),
+      "Analysis complete"
+    ) : await (async () => {
+      logger.info("Analyzing commits...");
+      return 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");
@@ -1966,8 +2898,12 @@ recordCommand.command("stop").description("Stop recording and generate a plan fr
     }
     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();
+    if (interactive) {
+      p10.outro("Edit the generated plan, then run `planmode test` to validate and `planmode publish` when ready.");
+    } else {
+      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);
@@ -1983,6 +2919,7 @@ recordCommand.command("status").description("Check if a recording is in progress
 
 // src/commands/snapshot.ts
 import { Command as Command15 } from "commander";
+import * as p11 from "@clack/prompts";
 import fs14 from "fs";
 import path14 from "path";
 
@@ -2257,14 +3194,29 @@ function detectCategory(data) {
 }
 
 // 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) => {
+init_logger();
+init_prompts();
+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(async (options) => {
   try {
-    logger.blank();
-    logger.info("Analyzing project...");
-    const result = takeSnapshot(process.cwd(), {
-      name: options.name,
-      author: options.author
-    });
+    const interactive = isInteractive();
+    if (interactive) {
+      p11.intro("Taking project snapshot");
+    } else {
+      logger.blank();
+    }
+    const doSnapshot = () => Promise.resolve(
+      takeSnapshot(process.cwd(), {
+        name: options.name,
+        author: options.author
+      })
+    );
+    const result = interactive ? await withSpinner("Analyzing project...", doSnapshot, "Analysis complete") : (() => {
+      logger.info("Analyzing project...");
+      return 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");
@@ -2279,8 +3231,12 @@ var snapshotCommand = new Command15("snapshot").description("Analyze the current
     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();
+    if (interactive) {
+      p11.outro("Edit the generated plan, then run `planmode test` to validate and `planmode publish` when ready.");
+    } else {
+      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);
@@ -2288,8 +3244,9 @@ var snapshotCommand = new Command15("snapshot").description("Analyze the current
 });
 
 // src/index.ts
+init_prompts();
 var program = new Command16();
-program.name("planmode").description("The open source package manager for AI plans, rules, and prompts.").version("0.2.2");
+program.name("planmode").description("The open source package manager for AI plans, rules, and prompts.").version("0.3.0");
 program.addCommand(installCommand);
 program.addCommand(uninstallCommand);
 program.addCommand(searchCommand);
@@ -2305,4 +3262,9 @@ program.addCommand(doctorCommand);
 program.addCommand(testCommand);
 program.addCommand(recordCommand);
 program.addCommand(snapshotCommand);
-program.parse();
+if (process.argv.length <= 2 && isInteractive()) {
+  const { runInteractiveMenu: runInteractiveMenu2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
+  runInteractiveMenu2();
+} else {
+  program.parse();
+}