planmode 0.1.5 → 0.2.1

package/dist/mcp.js

@@ -0,0 +1,2435 @@
+#!/usr/bin/env node
+
+// src/mcp.ts
+import fs12 from "fs";
+import path12 from "path";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod/v4";
+
+// 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 = [];
+    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}`);
+      }
+    }
+  },
+  blank() {
+    if (capturing) {
+      captured.push("");
+    } else {
+      console.log();
+    }
+  }
+};
+
+// src/lib/registry.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// 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;
+}
+function getCacheTTL() {
+  const config = readConfig();
+  return config.cache?.ttl ?? 3600;
+}
+function readConfig() {
+  try {
+    const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
+    return parse(raw) ?? {};
+  } catch {
+    return {};
+  }
+}
+function getGitHubToken() {
+  const envToken = process.env["PLANMODE_GITHUB_TOKEN"];
+  if (envToken) return envToken;
+  const config = readConfig();
+  return config.auth?.github_token;
+}
+function getRegistries() {
+  const config = readConfig();
+  return {
+    default: "github.com/kaihannonen/planmode.org/registry",
+    ...config.registries
+  };
+}
+
+// src/lib/registry.ts
+var INDEX_CACHE_FILE = "index.json";
+function getHeaders() {
+  const headers = {
+    "Accept": "application/vnd.github.v3.raw+json",
+    "User-Agent": "planmode-cli"
+  };
+  const token = getGitHubToken();
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  return headers;
+}
+function registryRawUrl(registryUrl, filePath) {
+  const match = registryUrl.match(/^github\.com\/([^/]+)\/([^/]+)(?:\/(.+))?$/);
+  if (!match) {
+    throw new Error(`Invalid registry URL: ${registryUrl}`);
+  }
+  const subpath = match[3] ? `${match[3]}/` : "";
+  return `https://raw.githubusercontent.com/${match[1]}/${match[2]}/main/${subpath}${filePath}`;
+}
+function resolveRegistry(packageName) {
+  const registries = getRegistries();
+  if (packageName.startsWith("@")) {
+    const scope = packageName.split("/")[0].slice(1);
+    const registryUrl = registries[scope];
+    if (!registryUrl) {
+      throw new Error(
+        `No registry configured for scope "@${scope}". Run: planmode registry add ${scope} <url>`
+      );
+    }
+    return registryUrl;
+  }
+  return registries["default"];
+}
+async function fetchIndex(registryUrl) {
+  const url = registryUrl ?? getRegistries()["default"];
+  const cacheDir = getCacheDir();
+  const cachePath = path2.join(cacheDir, INDEX_CACHE_FILE);
+  const ttl = getCacheTTL();
+  try {
+    const stat = fs2.statSync(cachePath);
+    const ageSeconds = (Date.now() - stat.mtimeMs) / 1e3;
+    if (ageSeconds < ttl) {
+      const cached = JSON.parse(fs2.readFileSync(cachePath, "utf-8"));
+      return cached;
+    }
+  } catch {
+  }
+  const rawUrl = registryRawUrl(url, "index.json");
+  const response = await fetch(rawUrl, { headers: getHeaders() });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch registry index: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  fs2.mkdirSync(cacheDir, { recursive: true });
+  fs2.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  return data;
+}
+async function searchPackages(query, options) {
+  const index = await fetchIndex();
+  const q = query.toLowerCase();
+  let results = index.packages.filter((pkg) => {
+    const searchable = [pkg.name, pkg.description, pkg.author, ...pkg.tags].join(" ").toLowerCase();
+    return searchable.includes(q);
+  });
+  if (options?.type) {
+    results = results.filter((pkg) => pkg.type === options.type);
+  }
+  if (options?.category) {
+    results = results.filter((pkg) => pkg.category === options.category);
+  }
+  return results.sort((a, b) => b.downloads - a.downloads);
+}
+async function fetchPackageMetadata(packageName) {
+  const registryUrl = resolveRegistry(packageName);
+  const name = packageName.startsWith("@") ? packageName.split("/")[1] : packageName;
+  const rawUrl = registryRawUrl(registryUrl, `packages/${name}/metadata.json`);
+  const response = await fetch(rawUrl, { headers: getHeaders() });
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(
+        `Package '${packageName}' not found in registry. Run \`planmode search <query>\` to find packages.`
+      );
+    }
+    throw new Error(`Failed to fetch package metadata: ${response.status}`);
+  }
+  return await response.json();
+}
+async function fetchVersionMetadata(packageName, version) {
+  const registryUrl = resolveRegistry(packageName);
+  const name = packageName.startsWith("@") ? packageName.split("/")[1] : packageName;
+  const rawUrl = registryRawUrl(registryUrl, `packages/${name}/versions/${version}.json`);
+  const response = await fetch(rawUrl, { headers: getHeaders() });
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(`Version '${version}' not found for '${packageName}'.`);
+    }
+    throw new Error(`Failed to fetch version metadata: ${response.status}`);
+  }
+  return await response.json();
+}
+
+// src/lib/installer.ts
+import fs7 from "fs";
+import path7 from "path";
+import crypto from "crypto";
+
+// src/lib/resolver.ts
+function parseSemver(version) {
+  const parts = version.split(".").map(Number);
+  return { major: parts[0], minor: parts[1], patch: parts[2] };
+}
+function parseVersionRange(range) {
+  if (range === "*") {
+    return { operator: "any", major: 0, minor: 0, patch: 0 };
+  }
+  if (range.startsWith("^")) {
+    const { major: major2, minor: minor2, patch: patch2 } = parseSemver(range.slice(1));
+    return { operator: "caret", major: major2, minor: minor2, patch: patch2 };
+  }
+  if (range.startsWith("~")) {
+    const { major: major2, minor: minor2, patch: patch2 } = parseSemver(range.slice(1));
+    return { operator: "tilde", major: major2, minor: minor2, patch: patch2 };
+  }
+  if (range.startsWith(">=")) {
+    const { major: major2, minor: minor2, patch: patch2 } = parseSemver(range.slice(2));
+    return { operator: "gte", major: major2, minor: minor2, patch: patch2 };
+  }
+  const { major, minor, patch } = parseSemver(range);
+  return { operator: "exact", major, minor, patch };
+}
+function satisfies(version, range) {
+  const v = parseSemver(version);
+  switch (range.operator) {
+    case "any":
+      return true;
+    case "exact":
+      return v.major === range.major && v.minor === range.minor && v.patch === range.patch;
+    case "caret":
+      if (v.major !== range.major) return false;
+      if (v.minor > range.minor) return true;
+      if (v.minor === range.minor) return v.patch >= range.patch;
+      return false;
+    case "tilde":
+      if (v.major !== range.major) return false;
+      if (v.minor !== range.minor) return false;
+      return v.patch >= range.patch;
+    case "gte":
+      if (v.major > range.major) return true;
+      if (v.major < range.major) return false;
+      if (v.minor > range.minor) return true;
+      if (v.minor < range.minor) return false;
+      return v.patch >= range.patch;
+  }
+}
+function compareVersions(a, b) {
+  const va = parseSemver(a);
+  const vb = parseSemver(b);
+  if (va.major !== vb.major) return va.major - vb.major;
+  if (va.minor !== vb.minor) return va.minor - vb.minor;
+  return va.patch - vb.patch;
+}
+function parseDepString(dep) {
+  const atIndex = dep.lastIndexOf("@");
+  if (atIndex > 0) {
+    return {
+      name: dep.slice(0, atIndex),
+      range: dep.slice(atIndex + 1)
+    };
+  }
+  return { name: dep, range: "*" };
+}
+async function resolveVersion(packageName, versionRange) {
+  const metadata = await fetchPackageMetadata(packageName);
+  if (!versionRange || versionRange === "latest") {
+    return { version: metadata.latest_version, metadata };
+  }
+  const range = parseVersionRange(versionRange);
+  const matching = metadata.versions.filter((v) => satisfies(v, range)).sort(compareVersions);
+  if (matching.length === 0) {
+    throw new Error(
+      `Version '${versionRange}' not found for '${packageName}'. Available: ${metadata.versions.join(", ")}`
+    );
+  }
+  const version = matching[matching.length - 1];
+  return { version, metadata };
+}
+
+// src/lib/git.ts
+import fs3 from "fs";
+import path3 from "path";
+import os2 from "os";
+import { simpleGit } from "simple-git";
+function repoCloneUrl(repoUrl) {
+  const token = getGitHubToken();
+  const match = repoUrl.match(/^github\.com\/(.+)$/);
+  if (!match) return `https://${repoUrl}.git`;
+  if (token) {
+    return `https://${token}@github.com/${match[1]}.git`;
+  }
+  return `https://github.com/${match[1]}.git`;
+}
+async function cloneAtTag(repoUrl, tag, targetDir) {
+  const cloneUrl = repoCloneUrl(repoUrl);
+  const git = simpleGit();
+  await git.clone(cloneUrl, targetDir, [
+    "--depth",
+    "1",
+    "--branch",
+    tag,
+    "--single-branch"
+  ]);
+}
+async function fetchFileAtTag(repoUrl, tag, filePath) {
+  const match = repoUrl.match(/^github\.com\/([^/]+)\/([^/]+)$/);
+  if (match) {
+    const token = getGitHubToken();
+    const rawUrl = `https://raw.githubusercontent.com/${match[1]}/${match[2]}/${tag}/${filePath}`;
+    const headers = { "User-Agent": "planmode-cli" };
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+    const response = await fetch(rawUrl, { headers });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${filePath} from ${repoUrl}@${tag}: ${response.status}`);
+    }
+    return response.text();
+  }
+  const tmpDir = fs3.mkdtempSync(path3.join(os2.tmpdir(), "planmode-"));
+  try {
+    await cloneAtTag(repoUrl, tag, tmpDir);
+    const fullPath = path3.join(tmpDir, filePath);
+    if (!fs3.existsSync(fullPath)) {
+      throw new Error(`File not found: ${filePath} in ${repoUrl}@${tag}`);
+    }
+    return fs3.readFileSync(fullPath, "utf-8");
+  } finally {
+    fs3.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+async function createTag(dir, tag) {
+  const git = simpleGit(dir);
+  await git.addTag(tag);
+}
+async function pushTag(dir, tag) {
+  const git = simpleGit(dir);
+  await git.push("origin", tag);
+}
+async function getRemoteUrl(dir) {
+  try {
+    const git = simpleGit(dir);
+    const remotes = await git.getRemotes(true);
+    const origin = remotes.find((r) => r.name === "origin");
+    return origin?.refs?.fetch ?? null;
+  } catch {
+    return null;
+  }
+}
+async function getHeadSha(dir) {
+  const git = simpleGit(dir);
+  const log = await git.log({ n: 1 });
+  return log.latest?.hash ?? "";
+}
+
+// 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);
+}
+function readLockfile(projectDir = process.cwd()) {
+  const lockfilePath = getLockfilePath(projectDir);
+  try {
+    const raw = fs4.readFileSync(lockfilePath, "utf-8");
+    const data = parse2(raw);
+    return data ?? { lockfile_version: 1, packages: {} };
+  } catch {
+    return { lockfile_version: 1, packages: {} };
+  }
+}
+function writeLockfile(lockfile, projectDir = process.cwd()) {
+  const lockfilePath = getLockfilePath(projectDir);
+  fs4.writeFileSync(lockfilePath, stringify2(lockfile), "utf-8");
+}
+function addToLockfile(packageName, entry, projectDir = process.cwd()) {
+  const lockfile = readLockfile(projectDir);
+  lockfile.packages[packageName] = entry;
+  writeLockfile(lockfile, projectDir);
+}
+function removeFromLockfile(packageName, projectDir = process.cwd()) {
+  const lockfile = readLockfile(projectDir);
+  delete lockfile.packages[packageName];
+  writeLockfile(lockfile, projectDir);
+}
+function getLockedVersion(packageName, projectDir = process.cwd()) {
+  const lockfile = readLockfile(projectDir);
+  return lockfile.packages[packageName];
+}
+
+// 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);
+}
+function addImport(planName, projectDir = process.cwd()) {
+  const claudeMdPath = getClaudeMdPath(projectDir);
+  const importLine = `- @plans/${planName}.md`;
+  if (!fs5.existsSync(claudeMdPath)) {
+    const content2 = `${PLANMODE_SECTION}
+${importLine}
+`;
+    fs5.writeFileSync(claudeMdPath, content2, "utf-8");
+    return;
+  }
+  const content = fs5.readFileSync(claudeMdPath, "utf-8");
+  if (content.includes(importLine)) {
+    return;
+  }
+  if (content.includes(PLANMODE_SECTION)) {
+    const updated = content.replace(PLANMODE_SECTION, `${PLANMODE_SECTION}
+${importLine}`);
+    fs5.writeFileSync(claudeMdPath, updated, "utf-8");
+  } else {
+    const separator = content.endsWith("\n") ? "\n" : "\n\n";
+    const updated = content + separator + `${PLANMODE_SECTION}
+${importLine}
+`;
+    fs5.writeFileSync(claudeMdPath, updated, "utf-8");
+  }
+}
+function removeImport(planName, projectDir = process.cwd()) {
+  const claudeMdPath = getClaudeMdPath(projectDir);
+  if (!fs5.existsSync(claudeMdPath)) return;
+  const content = fs5.readFileSync(claudeMdPath, "utf-8");
+  const importLine = `- @plans/${planName}.md`;
+  const updated = content.split("\n").filter((line) => line.trim() !== importLine).join("\n");
+  fs5.writeFileSync(claudeMdPath, updated, "utf-8");
+}
+function listImports(projectDir = process.cwd()) {
+  const claudeMdPath = getClaudeMdPath(projectDir);
+  if (!fs5.existsSync(claudeMdPath)) return [];
+  const content = fs5.readFileSync(claudeMdPath, "utf-8");
+  const importRegex = /^-\s*@plans\/(.+)\.md$/gm;
+  const imports = [];
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    imports.push(match[1]);
+  }
+  return imports;
+}
+
+// src/lib/manifest.ts
+import fs6 from "fs";
+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") {
+    throw new Error("Invalid YAML: manifest must be an object");
+  }
+  return data;
+}
+function readManifest(dir) {
+  const manifestPath = path6.join(dir, "planmode.yaml");
+  if (!fs6.existsSync(manifestPath)) {
+    throw new Error(`No planmode.yaml found in ${dir}`);
+  }
+  const raw = fs6.readFileSync(manifestPath, "utf-8");
+  return parseManifest(raw);
+}
+function validateManifest(manifest, requirePublishFields = false) {
+  const errors = [];
+  if (!manifest.name) {
+    errors.push("Missing required field: name");
+  } else if (!NAME_REGEX.test(manifest.name)) {
+    errors.push(`Invalid name "${manifest.name}": must match ${NAME_REGEX}`);
+  } else if (manifest.name.length > 100) {
+    errors.push("Name must be 100 characters or fewer");
+  }
+  if (!manifest.version) {
+    errors.push("Missing required field: version");
+  } else if (!SEMVER_REGEX.test(manifest.version)) {
+    errors.push(`Invalid version "${manifest.version}": must be valid semver (X.Y.Z)`);
+  }
+  if (!manifest.type) {
+    errors.push("Missing required field: type");
+  } else if (!VALID_TYPES.includes(manifest.type)) {
+    errors.push(`Invalid type "${manifest.type}": must be one of ${VALID_TYPES.join(", ")}`);
+  }
+  if (requirePublishFields) {
+    if (!manifest.description) errors.push("Missing required field: description");
+    if (manifest.description && manifest.description.length > 200) {
+      errors.push("Description must be 200 characters or fewer");
+    }
+    if (!manifest.author) errors.push("Missing required field: author");
+    if (!manifest.license) errors.push("Missing required field: license");
+  }
+  if (manifest.tags) {
+    if (manifest.tags.length > 10) {
+      errors.push("Maximum 10 tags allowed");
+    }
+    for (const tag of manifest.tags) {
+      if (!/^[a-z0-9][a-z0-9-]*$/.test(tag)) {
+        errors.push(`Invalid tag "${tag}": must be lowercase alphanumeric with hyphens`);
+      }
+    }
+  }
+  if (manifest.category && !VALID_CATEGORIES.includes(manifest.category)) {
+    errors.push(`Invalid category "${manifest.category}": must be one of ${VALID_CATEGORIES.join(", ")}`);
+  }
+  if (manifest.dependencies && manifest.type === "prompt") {
+    errors.push("Dependencies are not allowed for prompt type packages");
+  }
+  if (manifest.variables) {
+    for (const [varName, varDef] of Object.entries(manifest.variables)) {
+      if (!varDef.type || !VALID_VAR_TYPES.includes(varDef.type)) {
+        errors.push(`Variable "${varName}" has invalid type: must be one of ${VALID_VAR_TYPES.join(", ")}`);
+      }
+      if (varDef.type === "enum" && (!varDef.options || varDef.options.length === 0)) {
+        errors.push(`Variable "${varName}" of type enum must have options`);
+      }
+    }
+  }
+  if (manifest.content && manifest.content_file) {
+    errors.push("Cannot specify both content and content_file");
+  }
+  return errors;
+}
+function readPackageContent(dir, manifest) {
+  if (manifest.content) {
+    return manifest.content;
+  }
+  if (manifest.content_file) {
+    const contentPath = path6.join(dir, manifest.content_file);
+    if (!fs6.existsSync(contentPath)) {
+      throw new Error(`Content file not found: ${manifest.content_file}`);
+    }
+    return fs6.readFileSync(contentPath, "utf-8");
+  }
+  throw new Error("Package must specify either content or content_file");
+}
+
+// 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);
+}
+function collectVariableValues(variableDefs, provided) {
+  const values = {};
+  for (const [name, def] of Object.entries(variableDefs)) {
+    const rawValue = provided[name];
+    if (rawValue !== void 0) {
+      values[name] = coerceValue(rawValue, def);
+    } else if (def.default !== void 0) {
+      values[name] = def.default;
+    } else if (def.required) {
+      throw new Error(`Missing required variable: ${name} \u2014 ${def.description}`);
+    }
+  }
+  return values;
+}
+function coerceValue(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;
+  }
+}
+
+// src/lib/analytics.ts
+var API_BASE = "https://api.planmode.org";
+function trackDownload(packageName) {
+  fetch(`${API_BASE}/downloads/${encodeURIComponent(packageName)}`, {
+    method: "POST"
+  }).catch(() => {
+  });
+}
+
+// src/lib/installer.ts
+function getInstallDir(type) {
+  switch (type) {
+    case "plan":
+      return "plans";
+    case "rule":
+      return path7.join(".claude", "rules");
+    case "prompt":
+      return "prompts";
+  }
+}
+function getInstallPath(name, type) {
+  return path7.join(getInstallDir(type), `${name}.md`);
+}
+function contentHash(content) {
+  return `sha256:${crypto.createHash("sha256").update(content).digest("hex")}`;
+}
+async function installPackage(packageName, options = {}) {
+  const projectDir = options.projectDir ?? process.cwd();
+  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(
+      versionMeta.source.repository,
+      versionMeta.source.tag,
+      `${basePath}${manifest.content_file}`
+    );
+  } else {
+    throw new Error("Package has no content or content_file");
+  }
+  if (manifest.variables && Object.keys(manifest.variables).length > 0) {
+    const provided = options.variables ?? {};
+    if (options.noInput) {
+      const values = collectVariableValues(manifest.variables, provided);
+      content = renderTemplate(content, values);
+    } else {
+      const values = collectVariableValues(manifest.variables, provided);
+      content = renderTemplate(content, values);
+    }
+  }
+  const type = options.forceRule ? "rule" : manifest.type;
+  const installPath = getInstallPath(packageName, type);
+  const fullPath = path7.join(projectDir, installPath);
+  if (fs7.existsSync(fullPath)) {
+    const existingContent = fs7.readFileSync(fullPath, "utf-8");
+    const existingHash = contentHash(existingContent);
+    const newHash = contentHash(content);
+    if (existingHash === newHash) {
+      logger.dim(`${packageName} already installed (identical content)`);
+    } else {
+      logger.warn(`Overwriting ${installPath} with new content`);
+    }
+  }
+  const computedHash = contentHash(content);
+  if (versionMeta.content_hash && computedHash !== versionMeta.content_hash) {
+    logger.warn(
+      `Content hash mismatch for ${packageName}@${version}. Expected ${versionMeta.content_hash.slice(0, 20)}..., got ${computedHash.slice(0, 20)}... The package content may have been modified after review.`
+    );
+  }
+  fs7.mkdirSync(path7.dirname(fullPath), { recursive: true });
+  fs7.writeFileSync(fullPath, content, "utf-8");
+  logger.success(`Installed ${packageName}@${version} \u2192 ${installPath}`);
+  trackDownload(packageName);
+  if (type === "plan") {
+    addImport(packageName, projectDir);
+    logger.dim(`Added @plans/${packageName}.md to CLAUDE.md`);
+    logger.dim(`Claude Code will automatically see this plan in your next conversation.`);
+  }
+  if (type === "rule") {
+    logger.dim(`Rule is active \u2014 Claude Code auto-loads all files in .claude/rules/.`);
+  }
+  if (type === "prompt") {
+    logger.dim(`Run it with: planmode run ${packageName}`);
+  }
+  const hash = contentHash(content);
+  const entry = {
+    version,
+    type,
+    source: versionMeta.source.repository,
+    tag: versionMeta.source.tag,
+    sha: versionMeta.source.sha,
+    content_hash: hash,
+    installed_to: installPath
+  };
+  addToLockfile(packageName, entry, projectDir);
+  if (manifest.dependencies) {
+    const deps = [
+      ...(manifest.dependencies.rules ?? []).map((d) => ({ dep: d, type: "rule" })),
+      ...(manifest.dependencies.plans ?? []).map((d) => ({ dep: d, type: "plan" }))
+    ];
+    for (const { dep } of deps) {
+      const { name, range } = parseDepString(dep);
+      await installPackage(name, {
+        version: range === "*" ? void 0 : range,
+        projectDir,
+        noInput: options.noInput
+      });
+    }
+  }
+}
+async function uninstallPackage(packageName, projectDir = process.cwd()) {
+  const locked = getLockedVersion(packageName, projectDir);
+  if (!locked) {
+    throw new Error(`Package '${packageName}' is not installed.`);
+  }
+  const fullPath = path7.join(projectDir, locked.installed_to);
+  if (fs7.existsSync(fullPath)) {
+    fs7.unlinkSync(fullPath);
+    logger.success(`Removed ${locked.installed_to}`);
+  }
+  if (locked.type === "plan") {
+    removeImport(packageName, projectDir);
+    logger.dim(`Removed @import from CLAUDE.md`);
+  }
+  removeFromLockfile(packageName, projectDir);
+  logger.success(`Uninstalled ${packageName}`);
+}
+async function updatePackage(packageName, projectDir = process.cwd()) {
+  const locked = getLockedVersion(packageName, projectDir);
+  if (!locked) {
+    throw new Error(`Package '${packageName}' is not installed.`);
+  }
+  const { version, metadata } = await resolveVersion(packageName);
+  if (version === locked.version) {
+    logger.dim(`${packageName}@${version} is already up to date`);
+    return false;
+  }
+  logger.info(`Updating ${packageName}: ${locked.version} \u2192 ${version}`);
+  await uninstallPackage(packageName, projectDir);
+  await installPackage(packageName, { version, projectDir });
+  return true;
+}
+
+// src/lib/init.ts
+import fs8 from "fs";
+import path8 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 = path8.join(projectDir, "planmode.yaml");
+  fs8.writeFileSync(manifestPath, yamlContent, "utf-8");
+  const stubs = {
+    plan: getPlanTemplate(name),
+    rule: getRuleTemplate(name),
+    prompt: getPromptTemplate(name)
+  };
+  const contentPath = path8.join(projectDir, contentFile);
+  fs8.writeFileSync(contentPath, stubs[type] ?? stubs["plan"], "utf-8");
+  return {
+    files: ["planmode.yaml", contentFile],
+    manifestPath,
+    contentPath
+  };
+}
+
+// src/lib/publisher.ts
+async function publishPackage(options = {}) {
+  const cwd = options.projectDir ?? process.cwd();
+  const token = options.token ?? getGitHubToken();
+  if (!token) {
+    throw new Error("Not authenticated. Run `planmode login` first.");
+  }
+  logger.info("Reading planmode.yaml...");
+  const manifest = readManifest(cwd);
+  const errors = validateManifest(manifest, true);
+  if (errors.length > 0) {
+    throw new Error(`Invalid manifest:
+${errors.map((e) => `  - ${e}`).join("\n")}`);
+  }
+  const remoteUrl = await getRemoteUrl(cwd);
+  if (!remoteUrl) {
+    throw new Error("No git remote found. Push your code to GitHub first.");
+  }
+  const sha = await getHeadSha(cwd);
+  const tag = `v${manifest.version}`;
+  logger.info(`Creating tag ${tag}...`);
+  try {
+    await createTag(cwd, tag);
+  } catch {
+    logger.dim(`Tag ${tag} already exists, using existing`);
+  }
+  try {
+    await pushTag(cwd, tag);
+    logger.success(`Pushed tag ${tag}`);
+  } catch {
+    logger.dim(`Tag ${tag} already pushed`);
+  }
+  logger.info("Submitting to registry...");
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "planmode-cli",
+    "Content-Type": "application/json"
+  };
+  await fetch("https://api.github.com/repos/kaihannonen/planmode.org/forks", {
+    method: "POST",
+    headers
+  });
+  const userRes = await fetch("https://api.github.com/user", { headers });
+  if (!userRes.ok) {
+    throw new Error("Failed to authenticate with GitHub. Check your token.");
+  }
+  const user = await userRes.json();
+  const repoPath = remoteUrl.replace(/^https?:\/\//, "").replace(/\.git$/, "");
+  const metadataContent = JSON.stringify(
+    {
+      name: manifest.name,
+      description: manifest.description,
+      author: manifest.author,
+      license: manifest.license,
+      repository: repoPath,
+      category: manifest.category ?? "other",
+      tags: manifest.tags ?? [],
+      type: manifest.type,
+      models: manifest.models ?? [],
+      latest_version: manifest.version,
+      versions: [manifest.version],
+      downloads: 0,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      dependencies: manifest.dependencies,
+      variables: manifest.variables
+    },
+    null,
+    2
+  );
+  const versionContent = JSON.stringify(
+    {
+      version: manifest.version,
+      published_at: (/* @__PURE__ */ new Date()).toISOString(),
+      source: {
+        repository: repoPath,
+        tag,
+        sha
+      },
+      files: ["planmode.yaml", manifest.content_file ?? "inline"],
+      content_hash: `sha256:${sha.slice(0, 16)}`
+    },
+    null,
+    2
+  );
+  const branchName = `add-${manifest.name}-${manifest.version}`;
+  const refRes = await fetch(
+    `https://api.github.com/repos/${user.login}/planmode.org/git/ref/heads/main`,
+    { headers }
+  );
+  if (!refRes.ok) {
+    throw new Error("Failed to access registry fork. Make sure the fork exists.");
+  }
+  const refData = await refRes.json();
+  const baseSha = refData.object.sha;
+  await fetch(`https://api.github.com/repos/${user.login}/planmode.org/git/refs`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      ref: `refs/heads/${branchName}`,
+      sha: baseSha
+    })
+  });
+  await fetch(
+    `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/metadata.json`,
+    {
+      method: "PUT",
+      headers,
+      body: JSON.stringify({
+        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({
+      title: `Add ${manifest.name}@${manifest.version}`,
+      head: `${user.login}:${branchName}`,
+      base: "main",
+      body: `## New package: ${manifest.name}
+
+- **Type:** ${manifest.type}
+- **Version:** ${manifest.version}
+- **Description:** ${manifest.description}
+- **Author:** ${manifest.author}
+
+Submitted via \`planmode publish\`.`
+    })
+  });
+  if (!prRes.ok) {
+    const err = await prRes.text();
+    throw new Error(`Failed to create PR: ${err}`);
+  }
+  const pr = await prRes.json();
+  logger.success(`Published ${manifest.name}@${manifest.version}`);
+  logger.info(`PR: ${pr.html_url}`);
+  return {
+    prUrl: pr.html_url,
+    packageName: manifest.name,
+    version: manifest.version
+  };
+}
+
+// src/lib/doctor.ts
+import fs9 from "fs";
+import path9 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 = path9.join(projectDir, entry.installed_to);
+    if (!fs9.existsSync(fullPath)) {
+      issues.push({
+        severity: "error",
+        message: `Missing file for "${name}": ${entry.installed_to}`,
+        fix: `Run \`planmode install ${name}\` to reinstall`
+      });
+      continue;
+    }
+    const content = fs9.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 = path9.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 = path9.join(projectDir, "plans", `${importName}.md`);
+      if (!fs9.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 && !fs9.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 = path9.join(projectDir, "plans");
+  if (fs9.existsSync(plansDir)) {
+    const planFiles = fs9.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/lib/tester.ts
+async function testPackage(projectDir = process.cwd()) {
+  const issues = [];
+  const checks = [];
+  let manifest;
+  try {
+    manifest = readManifest(projectDir);
+    checks.push({ name: "Manifest parses", passed: true });
+  } catch (err) {
+    issues.push({
+      severity: "error",
+      check: "Manifest parses",
+      message: err.message
+    });
+    checks.push({ name: "Manifest parses", passed: false });
+    return { issues, passed: false, checks };
+  }
+  const errors = validateManifest(manifest, true);
+  if (errors.length === 0) {
+    checks.push({ name: "Manifest valid for publishing", passed: true });
+  } else {
+    for (const err of errors) {
+      issues.push({
+        severity: "error",
+        check: "Manifest valid for publishing",
+        message: err
+      });
+    }
+    checks.push({ name: "Manifest valid for publishing", passed: false });
+  }
+  let content;
+  try {
+    content = readPackageContent(projectDir, manifest);
+    if (content.trim().length === 0) {
+      issues.push({
+        severity: "warning",
+        check: "Content is non-empty",
+        message: "Content file is empty"
+      });
+      checks.push({ name: "Content is non-empty", passed: false });
+    } else {
+      checks.push({ name: "Content is non-empty", passed: true });
+    }
+  } catch (err) {
+    issues.push({
+      severity: "error",
+      check: "Content readable",
+      message: err.message
+    });
+    checks.push({ name: "Content readable", passed: false });
+  }
+  if (content && manifest.variables && Object.keys(manifest.variables).length > 0) {
+    try {
+      const missingDefaults = [];
+      for (const [name, def] of Object.entries(manifest.variables)) {
+        if (def.required && def.default === void 0) {
+          missingDefaults.push(name);
+        }
+      }
+      if (missingDefaults.length > 0) {
+        issues.push({
+          severity: "warning",
+          check: "Required variables have defaults",
+          message: `Required variables without defaults: ${missingDefaults.join(", ")}. Users must provide these at install time.`
+        });
+        checks.push({ name: "Required variables have defaults", passed: false });
+      } else {
+        checks.push({ name: "Required variables have defaults", passed: true });
+      }
+      const values = collectVariableValues(manifest.variables, {});
+      renderTemplate(content, values);
+      checks.push({ name: "Template renders with defaults", passed: true });
+    } catch (err) {
+      issues.push({
+        severity: "error",
+        check: "Template renders with defaults",
+        message: err.message
+      });
+      checks.push({ name: "Template renders with defaults", passed: false });
+    }
+  }
+  if (manifest.dependencies) {
+    const allDeps = [
+      ...manifest.dependencies.rules ?? [],
+      ...manifest.dependencies.plans ?? []
+    ];
+    for (const dep of allDeps) {
+      const depName = dep.includes("@") ? dep.split("@")[0] : dep;
+      try {
+        const results = await searchPackages(depName);
+        const found = results.some((r) => r.name === depName);
+        if (found) {
+          checks.push({ name: `Dependency "${depName}" exists`, passed: true });
+        } else {
+          issues.push({
+            severity: "warning",
+            check: `Dependency "${depName}" exists`,
+            message: `Dependency "${depName}" not found in registry. It may not be published yet.`
+          });
+          checks.push({ name: `Dependency "${depName}" exists`, passed: false });
+        }
+      } catch {
+        issues.push({
+          severity: "warning",
+          check: `Dependency "${depName}" exists`,
+          message: `Could not check registry for "${depName}" (network error)`
+        });
+        checks.push({ name: `Dependency "${depName}" exists`, passed: false });
+      }
+    }
+  }
+  if (content) {
+    const sizeKb = Buffer.byteLength(content, "utf-8") / 1024;
+    if (sizeKb > 100) {
+      issues.push({
+        severity: "warning",
+        check: "Content size reasonable",
+        message: `Content is ${sizeKb.toFixed(1)}KB. Large packages may hit token limits in AI models.`
+      });
+      checks.push({ name: "Content size reasonable", passed: false });
+    } else {
+      checks.push({ name: "Content size reasonable", passed: true });
+    }
+  }
+  const hasErrors = issues.some((i) => i.severity === "error");
+  return { issues, passed: !hasErrors, checks };
+}
+
+// src/lib/recorder.ts
+import fs10 from "fs";
+import path10 from "path";
+import { simpleGit as simpleGit2 } from "simple-git";
+import { stringify as stringify4 } from "yaml";
+var RECORDING_FILE = ".planmode-recording";
+function startRecording(projectDir = process.cwd()) {
+  const git = simpleGit2(projectDir);
+  const recordingPath = path10.join(projectDir, RECORDING_FILE);
+  if (fs10.existsSync(recordingPath)) {
+    const existing = fs10.readFileSync(recordingPath, "utf-8").trim();
+    throw new Error(
+      `Recording already in progress (started at ${existing}). Run \`planmode record stop\` first.`
+    );
+  }
+  return recordingPath;
+}
+async function startRecordingAsync(projectDir = process.cwd()) {
+  const recordingPath = startRecording(projectDir);
+  const git = simpleGit2(projectDir);
+  const log = await git.log({ n: 1 });
+  const sha = log.latest?.hash;
+  if (!sha) {
+    throw new Error("No commits found in this repository.");
+  }
+  fs10.writeFileSync(recordingPath, sha, "utf-8");
+  return sha;
+}
+function isRecording(projectDir = process.cwd()) {
+  return fs10.existsSync(path10.join(projectDir, RECORDING_FILE));
+}
+async function stopRecording(projectDir = process.cwd(), options = {}) {
+  const recordingPath = path10.join(projectDir, RECORDING_FILE);
+  if (!fs10.existsSync(recordingPath)) {
+    throw new Error("No recording in progress. Run `planmode record start` first.");
+  }
+  const startSha = fs10.readFileSync(recordingPath, "utf-8").trim();
+  const git = simpleGit2(projectDir);
+  const log = await git.log({ from: startSha, to: "HEAD" });
+  if (log.total === 0) {
+    fs10.unlinkSync(recordingPath);
+    throw new Error("No commits since recording started. Nothing to capture.");
+  }
+  const commits = [...log.all].reverse();
+  const steps = [];
+  const allFilesChanged = /* @__PURE__ */ new Set();
+  for (const commit of commits) {
+    const diff = await git.diffSummary([`${commit.hash}~1`, commit.hash]).catch(
+      () => (
+        // First commit in range might not have a parent in range
+        git.diffSummary([startSha, commit.hash])
+      )
+    );
+    const filesChanged = diff.files.map((f) => f.file);
+    filesChanged.forEach((f) => allFilesChanged.add(f));
+    const firstLine = commit.message.split("\n")[0].trim();
+    const body = commit.message.split("\n").slice(1).join("\n").trim();
+    steps.push({
+      title: firstLine,
+      message: body || firstLine,
+      filesChanged,
+      sha: commit.hash.slice(0, 7)
+    });
+  }
+  const planName = options.name || inferPlanName(steps);
+  const planContent = generatePlanContent(planName, steps);
+  const manifestContent = generateManifest(planName, options.author || "");
+  fs10.unlinkSync(recordingPath);
+  return {
+    steps,
+    planContent,
+    manifestContent,
+    totalCommits: commits.length,
+    totalFilesChanged: allFilesChanged.size
+  };
+}
+function inferPlanName(steps) {
+  const words = steps.map((s) => s.title.toLowerCase()).join(" ").replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 2 && !["the", "and", "for", "add", "fix", "update", "set"].includes(w));
+  const counts = /* @__PURE__ */ new Map();
+  for (const word of words) {
+    counts.set(word, (counts.get(word) || 0) + 1);
+  }
+  const topWords = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([w]) => w);
+  return topWords.length > 0 ? topWords.join("-") + "-setup" : "recorded-plan";
+}
+function generatePlanContent(name, steps) {
+  const lines = [];
+  lines.push(`# ${name}`);
+  lines.push("");
+  lines.push("## Steps");
+  lines.push("");
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    lines.push(`### ${i + 1}. ${step.title}`);
+    lines.push("");
+    if (step.message !== step.title) {
+      lines.push(step.message);
+      lines.push("");
+    }
+    if (step.filesChanged.length > 0) {
+      lines.push("**Files changed:**");
+      for (const file of step.filesChanged) {
+        lines.push(`- \`${file}\``);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("## Verification");
+  lines.push("");
+  lines.push("- [ ] All steps completed successfully");
+  lines.push("- [ ] Application builds without errors");
+  lines.push("- [ ] Tests pass");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateManifest(name, author) {
+  const manifest = {
+    name,
+    version: "1.0.0",
+    type: "plan",
+    description: `Plan recorded from git history`,
+    author: author || "unknown",
+    license: "MIT",
+    category: "other",
+    content_file: "plan.md"
+  };
+  return stringify4(manifest);
+}
+
+// src/lib/snapshot.ts
+import fs11 from "fs";
+import path11 from "path";
+import { stringify as stringify5 } from "yaml";
+var CONFIG_FILES = {
+  "tsconfig.json": "TypeScript",
+  "tsconfig.base.json": "TypeScript (base)",
+  ".eslintrc": "ESLint",
+  ".eslintrc.js": "ESLint",
+  ".eslintrc.json": "ESLint",
+  "eslint.config.js": "ESLint (flat config)",
+  "eslint.config.mjs": "ESLint (flat config)",
+  ".prettierrc": "Prettier",
+  ".prettierrc.json": "Prettier",
+  "prettier.config.js": "Prettier",
+  "tailwind.config.js": "Tailwind CSS",
+  "tailwind.config.ts": "Tailwind CSS",
+  "tailwind.config.mjs": "Tailwind CSS",
+  "postcss.config.js": "PostCSS",
+  "postcss.config.mjs": "PostCSS",
+  "next.config.js": "Next.js",
+  "next.config.mjs": "Next.js",
+  "next.config.ts": "Next.js",
+  "vite.config.ts": "Vite",
+  "vite.config.js": "Vite",
+  "astro.config.mjs": "Astro",
+  "astro.config.ts": "Astro",
+  "svelte.config.js": "SvelteKit",
+  "nuxt.config.ts": "Nuxt",
+  "remix.config.js": "Remix",
+  "webpack.config.js": "Webpack",
+  "rollup.config.js": "Rollup",
+  "vitest.config.ts": "Vitest",
+  "jest.config.js": "Jest",
+  "jest.config.ts": "Jest",
+  "docker-compose.yml": "Docker Compose",
+  "docker-compose.yaml": "Docker Compose",
+  "Dockerfile": "Docker",
+  ".dockerignore": "Docker",
+  "prisma/schema.prisma": "Prisma",
+  "drizzle.config.ts": "Drizzle ORM",
+  ".env.example": "Environment variables",
+  ".github/workflows": "GitHub Actions",
+  "vercel.json": "Vercel",
+  "netlify.toml": "Netlify",
+  "wrangler.toml": "Cloudflare Workers",
+  "fly.toml": "Fly.io"
+};
+function takeSnapshot(projectDir = process.cwd(), options = {}) {
+  const data = analyzeProject(projectDir);
+  if (options.name) {
+    data.name = options.name;
+  }
+  const planContent = generatePlanFromSnapshot(data);
+  const manifestContent = generateManifestFromSnapshot(data, options.author || "");
+  return { planContent, manifestContent, data };
+}
+function analyzeProject(projectDir) {
+  let name = path11.basename(projectDir) + "-setup";
+  const dependencies = {};
+  const devDependencies = {};
+  const scripts = {};
+  const pkgPath = path11.join(projectDir, "package.json");
+  if (fs11.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
+      if (pkg.name) name = pkg.name + "-setup";
+      if (pkg.dependencies) Object.assign(dependencies, pkg.dependencies);
+      if (pkg.devDependencies) Object.assign(devDependencies, pkg.devDependencies);
+      if (pkg.scripts) Object.assign(scripts, pkg.scripts);
+    } catch {
+    }
+  }
+  const detectedTools = [];
+  for (const [file, toolName] of Object.entries(CONFIG_FILES)) {
+    const fullPath = path11.join(projectDir, file);
+    if (fs11.existsSync(fullPath)) {
+      detectedTools.push({ name: toolName, file });
+    }
+  }
+  const structure = getDirectoryStructure(projectDir, 2);
+  const framework = detectFramework(dependencies, devDependencies);
+  name = name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return { name, dependencies, devDependencies, detectedTools, structure, scripts, framework };
+}
+function detectFramework(deps, devDeps) {
+  const all = { ...deps, ...devDeps };
+  if (all["next"]) return "Next.js";
+  if (all["astro"]) return "Astro";
+  if (all["@sveltejs/kit"]) return "SvelteKit";
+  if (all["nuxt"]) return "Nuxt";
+  if (all["@remix-run/react"]) return "Remix";
+  if (all["vue"]) return "Vue";
+  if (all["react"]) return "React";
+  if (all["express"]) return "Express";
+  if (all["fastify"]) return "Fastify";
+  if (all["hono"]) return "Hono";
+  return null;
+}
+function getDirectoryStructure(dir, maxDepth, depth = 0) {
+  const SKIP = /* @__PURE__ */ new Set([
+    "node_modules",
+    "dist",
+    ".git",
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    ".astro",
+    ".vercel",
+    ".netlify",
+    "build",
+    "coverage",
+    "__pycache__",
+    ".turbo",
+    ".cache"
+  ]);
+  const results = [];
+  try {
+    const entries = fs11.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".github") continue;
+      if (SKIP.has(entry.name)) continue;
+      const indent = "  ".repeat(depth);
+      if (entry.isDirectory()) {
+        results.push(`${indent}${entry.name}/`);
+        if (depth < maxDepth) {
+          results.push(...getDirectoryStructure(path11.join(dir, entry.name), maxDepth, depth + 1));
+        }
+      } else {
+        results.push(`${indent}${entry.name}`);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function generatePlanFromSnapshot(data) {
+  const lines = [];
+  lines.push(`# ${data.name}`);
+  lines.push("");
+  if (data.framework) {
+    lines.push(`Set up a ${data.framework} project with the following tools and configuration.`);
+  } else {
+    lines.push("Set up a project with the following tools and configuration.");
+  }
+  lines.push("");
+  lines.push("## Prerequisites");
+  lines.push("");
+  lines.push("- Node.js 20+");
+  if (Object.keys(data.dependencies).length > 0 || Object.keys(data.devDependencies).length > 0) {
+    lines.push("- npm or your preferred package manager");
+  }
+  const toolNames = [...new Set(data.detectedTools.map((t) => t.name))];
+  if (toolNames.includes("Docker") || toolNames.includes("Docker Compose")) {
+    lines.push("- Docker");
+  }
+  if (toolNames.includes("Prisma")) {
+    lines.push("- A PostgreSQL database (or update the Prisma schema for your database)");
+  }
+  lines.push("");
+  lines.push("## Steps");
+  lines.push("");
+  let stepNum = 1;
+  if (data.framework) {
+    lines.push(`### ${stepNum}. Create ${data.framework} project`);
+    lines.push("");
+    lines.push(`Initialize a new ${data.framework} project.`);
+    lines.push("");
+    stepNum++;
+  }
+  const depNames = Object.keys(data.dependencies);
+  const devDepNames = Object.keys(data.devDependencies);
+  if (depNames.length > 0) {
+    lines.push(`### ${stepNum}. Install dependencies`);
+    lines.push("");
+    lines.push("```bash");
+    lines.push(`npm install ${depNames.join(" ")}`);
+    lines.push("```");
+    lines.push("");
+    stepNum++;
+  }
+  if (devDepNames.length > 0) {
+    lines.push(`### ${stepNum}. Install dev dependencies`);
+    lines.push("");
+    lines.push("```bash");
+    lines.push(`npm install -D ${devDepNames.join(" ")}`);
+    lines.push("```");
+    lines.push("");
+    stepNum++;
+  }
+  for (const tool of data.detectedTools) {
+    if (tool.name === data.framework) continue;
+    if (tool.name === "Environment variables") continue;
+    lines.push(`### ${stepNum}. Configure ${tool.name}`);
+    lines.push("");
+    lines.push(`Create or update \`${tool.file}\` with the appropriate configuration.`);
+    lines.push("");
+    stepNum++;
+  }
+  if (data.detectedTools.some((t) => t.name === "Environment variables")) {
+    lines.push(`### ${stepNum}. Set up environment variables`);
+    lines.push("");
+    lines.push("Copy `.env.example` to `.env` and fill in the values:");
+    lines.push("");
+    lines.push("```bash");
+    lines.push("cp .env.example .env");
+    lines.push("```");
+    lines.push("");
+    stepNum++;
+  }
+  if (Object.keys(data.scripts).length > 0) {
+    lines.push(`### ${stepNum}. Available scripts`);
+    lines.push("");
+    for (const [name, cmd] of Object.entries(data.scripts)) {
+      lines.push(`- \`npm run ${name}\` \u2014 \`${cmd}\``);
+    }
+    lines.push("");
+    stepNum++;
+  }
+  if (data.structure.length > 0) {
+    lines.push("## Project Structure");
+    lines.push("");
+    lines.push("```");
+    for (const line of data.structure.slice(0, 40)) {
+      lines.push(line);
+    }
+    if (data.structure.length > 40) {
+      lines.push("  ...");
+    }
+    lines.push("```");
+    lines.push("");
+  }
+  lines.push("## Verification");
+  lines.push("");
+  lines.push("- [ ] All dependencies installed without errors");
+  lines.push("- [ ] Configuration files are in place");
+  if (data.scripts["build"]) lines.push("- [ ] `npm run build` succeeds");
+  if (data.scripts["test"]) lines.push("- [ ] `npm run test` passes");
+  if (data.scripts["dev"]) lines.push("- [ ] `npm run dev` starts without errors");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateManifestFromSnapshot(data, author) {
+  const tags = [];
+  if (data.framework) tags.push(data.framework.toLowerCase().replace(/[^a-z0-9]/g, ""));
+  const toolTags = data.detectedTools.map((t) => t.name.toLowerCase().replace(/[^a-z0-9]/g, "-")).filter((t) => t.length > 1);
+  tags.push(...[...new Set(toolTags)].slice(0, 8));
+  const category = detectCategory(data);
+  const manifest = {
+    name: data.name,
+    version: "1.0.0",
+    type: "plan",
+    description: data.framework ? `Set up a ${data.framework} project with ${data.detectedTools.map((t) => t.name).slice(0, 3).join(", ")}` : `Project setup with ${data.detectedTools.map((t) => t.name).slice(0, 3).join(", ")}`,
+    author: author || "unknown",
+    license: "MIT",
+    tags: tags.slice(0, 10),
+    category,
+    content_file: "plan.md"
+  };
+  return stringify5(manifest);
+}
+function detectCategory(data) {
+  const all = { ...data.dependencies, ...data.devDependencies };
+  if (all["react"] || all["vue"] || all["svelte"] || all["next"] || all["astro"]) return "frontend";
+  if (all["express"] || all["fastify"] || all["hono"] || all["koa"]) return "backend";
+  if (data.detectedTools.some((t) => t.name === "Docker" || t.name === "Docker Compose")) return "devops";
+  if (all["prisma"] || all["drizzle-orm"] || all["typeorm"]) return "database";
+  return "other";
+}
+
+// src/mcp.ts
+function withCapture(fn) {
+  logger.capture();
+  try {
+    const result = fn();
+    const messages = logger.flush();
+    return { result, messages };
+  } catch (err) {
+    const messages = logger.flush();
+    throw Object.assign(err, { capturedMessages: messages });
+  }
+}
+async function withCaptureAsync(fn) {
+  logger.capture();
+  try {
+    const result = await fn();
+    const messages = logger.flush();
+    return { result, messages };
+  } catch (err) {
+    const messages = logger.flush();
+    throw Object.assign(err, { capturedMessages: messages });
+  }
+}
+function textResult(text, isError = false) {
+  return {
+    content: [{ type: "text", text }],
+    isError
+  };
+}
+function formatMessages(messages, extra) {
+  const parts = [];
+  if (messages.length > 0) {
+    parts.push(messages.filter((m) => m !== "").join("\n"));
+  }
+  if (extra) {
+    parts.push(extra);
+  }
+  return parts.join("\n\n");
+}
+function adaptError(message) {
+  return message.replace(/Run `planmode login` first\./, "Authentication required. Configure a GitHub token via `planmode login` in your terminal, or set the PLANMODE_GITHUB_TOKEN environment variable.").replace(/Run `planmode search <query>` to find packages\./, "Try using the planmode_search tool to find packages.").replace(/Run `planmode install (.+?)` to get started\./, "Use the planmode_install tool to install packages.").replace(/Install it first: planmode install (.+)/, "Install it first using the planmode_install tool.").replace(/run `planmode publish` when ready\./, "use the planmode_publish tool when ready.");
+}
+function errorResult(prefix, err) {
+  const capturedMessages = err.capturedMessages;
+  const msgPrefix = capturedMessages?.length ? capturedMessages.join("\n") + "\n\n" : "";
+  return textResult(adaptError(`${msgPrefix}${prefix}: ${err.message}`), true);
+}
+var server = new McpServer({
+  name: "planmode",
+  version: "0.2.1"
+});
+server.registerTool(
+  "planmode_search",
+  {
+    description: "Search the planmode registry for packages (plans, rules, and prompts for AI-assisted development)",
+    inputSchema: {
+      query: z.string().describe("Search query to find packages"),
+      type: z.enum(["prompt", "rule", "plan"]).optional().describe("Filter by package type"),
+      category: z.string().optional().describe("Filter by category (frontend, backend, devops, database, testing, mobile, ai-ml, design, security, other)")
+    }
+  },
+  async ({ query, type, category }) => {
+    try {
+      const { result: results, messages } = await withCaptureAsync(
+        () => searchPackages(query, { type, category })
+      );
+      if (results.length === 0) {
+        return textResult(formatMessages(messages, "No packages found matching your query."));
+      }
+      const table = results.map(
+        (pkg) => `- **${pkg.name}** (${pkg.type} v${pkg.version}) \u2014 ${pkg.description}`
+      ).join("\n");
+      return textResult(formatMessages(messages, `Found ${results.length} package(s):
+
+${table}`));
+    } catch (err) {
+      return errorResult("Error searching registry", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_info",
+  {
+    description: "Get detailed information about a planmode package including versions, dependencies, and variables. Use this before installing to understand what a package provides and what variables it needs.",
+    inputSchema: {
+      package: z.string().describe("Package name (e.g., nextjs-tailwind-starter)")
+    }
+  },
+  async ({ package: packageName }) => {
+    try {
+      const { result: meta, messages } = await withCaptureAsync(
+        () => fetchPackageMetadata(packageName)
+      );
+      const lines = [
+        `# ${meta.name}@${meta.latest_version}`,
+        "",
+        `**Description:** ${meta.description}`,
+        `**Type:** ${meta.type}`,
+        `**Author:** ${meta.author}`,
+        `**License:** ${meta.license}`,
+        `**Category:** ${meta.category}`,
+        `**Downloads:** ${meta.downloads.toLocaleString()}`,
+        `**Repository:** ${meta.repository}`
+      ];
+      if (meta.models && meta.models.length > 0) {
+        lines.push(`**Models:** ${meta.models.join(", ")}`);
+      }
+      if (meta.tags && meta.tags.length > 0) {
+        lines.push(`**Tags:** ${meta.tags.join(", ")}`);
+      }
+      lines.push(`**Versions:** ${meta.versions.join(", ")}`);
+      if (meta.dependencies) {
+        if (meta.dependencies.rules?.length) {
+          lines.push(`**Dependencies (rules):** ${meta.dependencies.rules.join(", ")}`);
+        }
+        if (meta.dependencies.plans?.length) {
+          lines.push(`**Dependencies (plans):** ${meta.dependencies.plans.join(", ")}`);
+        }
+      }
+      if (meta.variables) {
+        lines.push("", "**Variables:**");
+        for (const [name, def] of Object.entries(meta.variables)) {
+          const required = def.required ? " (required)" : "";
+          const defaultVal = def.default !== void 0 ? ` [default: ${def.default}]` : "";
+          lines.push(`- \`${name}\`: ${def.type}${required}${defaultVal} \u2014 ${def.description}`);
+          if (def.options) {
+            lines.push(`  Options: ${def.options.join(", ")}`);
+          }
+        }
+      }
+      return textResult(formatMessages(messages, lines.join("\n")));
+    } catch (err) {
+      return errorResult("Error fetching package info", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_preview",
+  {
+    description: "Preview the full content of a planmode package from the registry without installing it. Returns the raw markdown content so you can review what the package does before installing.",
+    inputSchema: {
+      package: z.string().describe("Package name to preview"),
+      version: z.string().optional().describe("Specific version to preview (default: latest)")
+    }
+  },
+  async ({ package: packageName, version }) => {
+    try {
+      const { result: resolved, messages: resolveMessages } = await withCaptureAsync(
+        () => resolveVersion(packageName, version)
+      );
+      const versionMeta = await fetchVersionMetadata(packageName, resolved.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(
+          versionMeta.source.repository,
+          versionMeta.source.tag,
+          `${basePath}${manifest.content_file}`
+        );
+      } else {
+        return textResult("Package has no content or content_file defined.", true);
+      }
+      const header = [
+        `# Preview: ${packageName}@${resolved.version}`,
+        `**Type:** ${manifest.type} | **Author:** ${manifest.author ?? "unknown"}`,
+        manifest.description ? `**Description:** ${manifest.description}` : ""
+      ].filter(Boolean).join("\n");
+      const variableNote = manifest.variables && Object.keys(manifest.variables).length > 0 ? `
+**Note:** This package uses template variables (${Object.keys(manifest.variables).join(", ")}). Content below shows raw templates.
+` : "";
+      return textResult(`${header}${variableNote}
+---
+
+${content}`);
+    } catch (err) {
+      return errorResult("Error previewing package", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_install",
+  {
+    description: "Install a planmode package into the current project. Places plans in plans/, rules in .claude/rules/, prompts in prompts/. Updates CLAUDE.md with @import for plans. Use planmode_info first to check for required variables.",
+    inputSchema: {
+      package: z.string().describe("Package name to install"),
+      version: z.string().optional().describe("Specific version to install (default: latest)"),
+      asRule: z.boolean().optional().describe("Force install as a rule to .claude/rules/"),
+      variables: z.record(z.string(), z.string()).optional().describe("Template variable values as key-value pairs"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ package: packageName, version, asRule, variables, projectDir }) => {
+    try {
+      const { messages } = await withCaptureAsync(
+        () => installPackage(packageName, {
+          version,
+          forceRule: asRule,
+          noInput: true,
+          variables,
+          projectDir
+        })
+      );
+      return textResult(adaptError(formatMessages(messages) || `Installed ${packageName} successfully.`));
+    } catch (err) {
+      return errorResult("Error installing package", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_uninstall",
+  {
+    description: "Remove an installed planmode package from the current project",
+    inputSchema: {
+      package: z.string().describe("Package name to uninstall"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ package: packageName, projectDir }) => {
+    try {
+      const { messages } = await withCaptureAsync(
+        () => uninstallPackage(packageName, projectDir)
+      );
+      return textResult(formatMessages(messages) || `Uninstalled ${packageName} successfully.`);
+    } catch (err) {
+      return errorResult("Error uninstalling package", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_list",
+  {
+    description: "List all planmode packages installed in the current project",
+    inputSchema: {
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ projectDir }) => {
+    try {
+      const lockfile = readLockfile(projectDir);
+      const entries = Object.entries(lockfile.packages);
+      if (entries.length === 0) {
+        return textResult("No packages installed. Use the planmode_install tool to install a package.");
+      }
+      const table = entries.map(
+        ([name, entry]) => `- **${name}** (${entry.type} v${entry.version}) \u2192 ${entry.installed_to}`
+      ).join("\n");
+      return textResult(`${entries.length} package(s) installed:
+
+${table}`);
+    } catch (err) {
+      return errorResult("Error listing packages", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_read",
+  {
+    description: "Read the content of an installed planmode package from disk. Use this to view what a plan, rule, or prompt contains after installation.",
+    inputSchema: {
+      package: z.string().describe("Package name to read"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ package: packageName, projectDir }) => {
+    try {
+      const dir = projectDir ?? process.cwd();
+      const lockfile = readLockfile(dir);
+      const entry = lockfile.packages[packageName];
+      if (!entry) {
+        const candidates = [
+          path12.join(dir, "plans", `${packageName}.md`),
+          path12.join(dir, ".claude", "rules", `${packageName}.md`),
+          path12.join(dir, "prompts", `${packageName}.md`)
+        ];
+        for (const candidate of candidates) {
+          if (fs12.existsSync(candidate)) {
+            const content2 = fs12.readFileSync(candidate, "utf-8");
+            const relativePath = path12.relative(dir, candidate);
+            return textResult(`# ${packageName}
+**Location:** ${relativePath}
+
+---
+
+${content2}`);
+          }
+        }
+        return textResult(
+          `Package '${packageName}' is not installed. Use planmode_list to see installed packages, or planmode_preview to view a package from the registry.`,
+          true
+        );
+      }
+      const fullPath = path12.join(dir, entry.installed_to);
+      if (!fs12.existsSync(fullPath)) {
+        return textResult(
+          `Package '${packageName}' is in the lockfile but the file is missing at ${entry.installed_to}. Try reinstalling with planmode_install.`,
+          true
+        );
+      }
+      const content = fs12.readFileSync(fullPath, "utf-8");
+      return textResult(
+        `# ${packageName} (${entry.type} v${entry.version})
+**Location:** ${entry.installed_to}
+
+---
+
+${content}`
+      );
+    } catch (err) {
+      return errorResult("Error reading package", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_update",
+  {
+    description: "Update installed planmode packages to their latest compatible versions",
+    inputSchema: {
+      package: z.string().optional().describe("Package name to update (omit to update all)"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ package: packageName, projectDir }) => {
+    try {
+      if (packageName) {
+        const { result: updated, messages } = await withCaptureAsync(
+          () => updatePackage(packageName, projectDir)
+        );
+        if (!updated) {
+          return textResult(formatMessages(messages, `${packageName} is already up to date.`));
+        }
+        return textResult(formatMessages(messages) || `Updated ${packageName} successfully.`);
+      }
+      const lockfile = readLockfile(projectDir);
+      const names = Object.keys(lockfile.packages);
+      if (names.length === 0) {
+        return textResult("No packages installed.");
+      }
+      const results = [];
+      let updatedCount = 0;
+      for (const name of names) {
+        try {
+          const { result: updated, messages } = await withCaptureAsync(
+            () => updatePackage(name, projectDir)
+          );
+          if (updated) {
+            updatedCount++;
+            results.push(`Updated ${name}`);
+          }
+        } catch (err) {
+          results.push(`Failed to update ${name}: ${err.message}`);
+        }
+      }
+      if (updatedCount === 0) {
+        return textResult("All packages are up to date.");
+      }
+      return textResult(`Updated ${updatedCount} package(s):
+
+${results.join("\n")}`);
+    } catch (err) {
+      return errorResult("Error updating packages", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_init",
+  {
+    description: "Initialize a new planmode package by creating planmode.yaml and a content stub file",
+    inputSchema: {
+      name: z.string().describe("Package name (lowercase, hyphens only)"),
+      type: z.enum(["plan", "rule", "prompt"]).describe("Package type"),
+      description: z.string().describe("Package description (max 200 chars)"),
+      author: z.string().describe("Author GitHub username"),
+      license: z.string().optional().describe("License identifier (default: MIT)"),
+      tags: z.array(z.string()).optional().describe("Tags for discovery (max 10)"),
+      category: z.enum([
+        "frontend",
+        "backend",
+        "devops",
+        "database",
+        "testing",
+        "mobile",
+        "ai-ml",
+        "design",
+        "security",
+        "other"
+      ]).optional().describe("Package category (default: other)"),
+      projectDir: z.string().optional().describe("Directory to create the package in (default: current working directory)")
+    }
+  },
+  async ({ name, type, description, author, license, tags, category, projectDir }) => {
+    try {
+      const { result, messages } = withCapture(
+        () => createPackage({
+          name,
+          type,
+          description,
+          author,
+          license,
+          tags,
+          category,
+          projectDir
+        })
+      );
+      return textResult(
+        formatMessages(
+          messages,
+          `Created package "${name}":
+- ${result.files.join("\n- ")}
+
+Edit the content file, then use the planmode_publish tool when ready.`
+        )
+      );
+    } catch (err) {
+      return errorResult("Error creating package", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_publish",
+  {
+    description: "Publish a planmode package to the registry. Creates a git tag, forks the registry, and opens a PR. Requires GitHub authentication (configure via `planmode login` in terminal or PLANMODE_GITHUB_TOKEN env var).",
+    inputSchema: {
+      projectDir: z.string().optional().describe("Directory containing planmode.yaml (default: current working directory)")
+    }
+  },
+  async ({ projectDir }) => {
+    try {
+      const { result, messages } = await withCaptureAsync(
+        () => publishPackage({ projectDir })
+      );
+      return textResult(
+        formatMessages(
+          messages,
+          `Published ${result.packageName}@${result.version}
+PR: ${result.prUrl}`
+        )
+      );
+    } catch (err) {
+      return errorResult("Error publishing package", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_validate",
+  {
+    description: "Validate a planmode.yaml manifest file for correctness",
+    inputSchema: {
+      projectDir: z.string().optional().describe("Directory containing planmode.yaml (default: current working directory)"),
+      requirePublishFields: z.boolean().optional().describe("Require fields needed for publishing (description, author, license)")
+    }
+  },
+  async ({ projectDir, requirePublishFields }) => {
+    try {
+      const dir = projectDir ?? process.cwd();
+      const manifest = readManifest(dir);
+      const errors = validateManifest(manifest, requirePublishFields ?? false);
+      if (errors.length === 0) {
+        return textResult(
+          `Manifest is valid: ${manifest.name}@${manifest.version} (${manifest.type})`
+        );
+      }
+      return textResult(
+        `Manifest validation failed:
+
+${errors.map((e) => `- ${e}`).join("\n")}`,
+        true
+      );
+    } catch (err) {
+      return errorResult("Error reading manifest", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_run",
+  {
+    description: "Render a templated planmode prompt with variables and return the result",
+    inputSchema: {
+      prompt: z.string().describe("Prompt package name (looks in prompts/ directory)"),
+      variables: z.record(z.string(), z.string()).optional().describe("Template variable values as key-value pairs"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ prompt: promptName, variables, projectDir }) => {
+    try {
+      const dir = projectDir ?? process.cwd();
+      const localPath = path12.join(dir, "prompts", `${promptName}.md`);
+      const localManifestPath = path12.join(dir, "prompts", promptName, "planmode.yaml");
+      let content;
+      let manifest;
+      if (fs12.existsSync(localManifestPath)) {
+        const raw = fs12.readFileSync(localManifestPath, "utf-8");
+        manifest = parseManifest(raw);
+        const promptDir = path12.join(dir, "prompts", promptName);
+        content = readPackageContent(promptDir, manifest);
+      } else if (fs12.existsSync(localPath)) {
+        content = fs12.readFileSync(localPath, "utf-8");
+      } else {
+        return textResult(
+          `Prompt '${promptName}' not found locally. Install it first using the planmode_install tool.`,
+          true
+        );
+      }
+      if (manifest?.variables && Object.keys(manifest.variables).length > 0) {
+        const provided = variables ?? {};
+        const values = collectVariableValues(manifest.variables, provided);
+        content = renderTemplate(content, values);
+      }
+      return textResult(content);
+    } catch (err) {
+      return errorResult("Error running prompt", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_doctor",
+  {
+    description: "Check project health: verify installed packages have matching files on disk, CLAUDE.md imports are correct, and content hashes haven't drifted. Use this to diagnose issues with planmode packages.",
+    inputSchema: {
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ projectDir }) => {
+    try {
+      const result = runDoctor(projectDir);
+      if (result.issues.length === 0) {
+        return textResult(`Checked ${result.packagesChecked} package(s) \u2014 all healthy. No issues found.`);
+      }
+      const lines = [`Checked ${result.packagesChecked} package(s):
+`];
+      for (const issue of result.issues) {
+        const icon = issue.severity === "error" ? "ERROR" : "WARN";
+        lines.push(`**${icon}:** ${issue.message}`);
+        if (issue.fix) {
+          lines.push(`  Fix: ${adaptError(issue.fix)}`);
+        }
+      }
+      const errors = result.issues.filter((i) => i.severity === "error").length;
+      const warnings = result.issues.filter((i) => i.severity === "warning").length;
+      lines.push("", `${errors} error(s), ${warnings} warning(s)`);
+      return textResult(lines.join("\n"), errors > 0);
+    } catch (err) {
+      return errorResult("Error running health check", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_test",
+  {
+    description: "Test a planmode package before publishing. Validates the manifest, checks that templates render with default values, verifies dependencies exist in the registry, and checks content size.",
+    inputSchema: {
+      projectDir: z.string().optional().describe("Directory containing planmode.yaml (default: current working directory)")
+    }
+  },
+  async ({ projectDir }) => {
+    try {
+      const { result, messages } = await withCaptureAsync(
+        () => testPackage(projectDir)
+      );
+      const lines = [];
+      for (const check of result.checks) {
+        if (check.passed) {
+          lines.push(`PASS: ${check.name}`);
+        } else {
+          const issue = result.issues.find((i) => i.check === check.name);
+          const severity = issue?.severity === "error" ? "FAIL" : "WARN";
+          lines.push(`${severity}: ${check.name}${issue ? ` \u2014 ${issue.message}` : ""}`);
+        }
+      }
+      lines.push("");
+      if (result.passed) {
+        lines.push("All checks passed. Ready to publish.");
+      } else {
+        const errors = result.issues.filter((i) => i.severity === "error").length;
+        const warnings = result.issues.filter((i) => i.severity === "warning").length;
+        lines.push(`${errors} error(s), ${warnings} warning(s). Fix errors before publishing.`);
+      }
+      return textResult(formatMessages(messages, lines.join("\n")), !result.passed);
+    } catch (err) {
+      return errorResult("Error testing package", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_record_start",
+  {
+    description: "Start recording git activity. Saves the current HEAD commit as the starting point. Work normally (make commits), then use planmode_record_stop to generate a plan from the commits.",
+    inputSchema: {
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ projectDir }) => {
+    try {
+      const dir = projectDir ?? process.cwd();
+      if (isRecording(dir)) {
+        return textResult("A recording is already in progress. Use planmode_record_stop to finish it first.", true);
+      }
+      const sha = await startRecordingAsync(dir);
+      return textResult(`Recording started at commit ${sha.slice(0, 7)}. Make commits as normal, then use planmode_record_stop to generate a plan.`);
+    } catch (err) {
+      return errorResult("Error starting recording", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_record_stop",
+  {
+    description: "Stop recording and generate a planmode package from the git commits made since recording started. Creates planmode.yaml and plan.md with each commit as a step.",
+    inputSchema: {
+      name: z.string().optional().describe("Package name (auto-inferred from commits if not provided)"),
+      author: z.string().optional().describe("Author GitHub username"),
+      outputDir: z.string().optional().describe("Directory to write planmode.yaml and plan.md (default: current working directory)"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ name, author, outputDir, projectDir }) => {
+    try {
+      const dir = projectDir ?? process.cwd();
+      const result = await stopRecording(dir, { name, author });
+      const outDir = outputDir ?? dir;
+      const fsModule = await import("fs");
+      const pathModule = await import("path");
+      fsModule.mkdirSync(outDir, { recursive: true });
+      fsModule.writeFileSync(pathModule.join(outDir, "planmode.yaml"), result.manifestContent, "utf-8");
+      fsModule.writeFileSync(pathModule.join(outDir, "plan.md"), result.planContent, "utf-8");
+      const stepList = result.steps.map((s, i) => `${i + 1}. ${s.title} (${s.filesChanged.length} files)`).join("\n");
+      return textResult(
+        `Generated plan from ${result.totalCommits} commit(s) (${result.totalFilesChanged} files changed):
+
+${stepList}
+
+Created planmode.yaml and plan.md. Edit the plan content, then use planmode_test to validate and planmode_publish to publish.`
+      );
+    } catch (err) {
+      return errorResult("Error stopping recording", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_snapshot",
+  {
+    description: "Analyze the current project and generate a planmode package that recreates this setup. Reads package.json, detects config files and tools, captures the directory structure, and creates a step-by-step plan.",
+    inputSchema: {
+      name: z.string().optional().describe("Package name (auto-inferred from project name)"),
+      author: z.string().optional().describe("Author GitHub username"),
+      outputDir: z.string().optional().describe("Directory to write planmode.yaml and plan.md (default: current working directory)"),
+      projectDir: z.string().optional().describe("Project to analyze (default: current working directory)")
+    }
+  },
+  async ({ name, author, outputDir, projectDir }) => {
+    try {
+      const dir = projectDir ?? process.cwd();
+      const result = takeSnapshot(dir, { name, author });
+      const outDir = outputDir ?? dir;
+      const fsModule = await import("fs");
+      const pathModule = await import("path");
+      fsModule.mkdirSync(outDir, { recursive: true });
+      fsModule.writeFileSync(pathModule.join(outDir, "planmode.yaml"), result.manifestContent, "utf-8");
+      fsModule.writeFileSync(pathModule.join(outDir, "plan.md"), result.planContent, "utf-8");
+      const toolList = result.data.detectedTools.map((t) => t.name).join(", ") || "none";
+      const depCount = Object.keys(result.data.dependencies).length;
+      const devDepCount = Object.keys(result.data.devDependencies).length;
+      let summary = `Snapshot: **${result.data.name}**
+`;
+      if (result.data.framework) summary += `Framework: ${result.data.framework}
+`;
+      summary += `Dependencies: ${depCount} | Dev dependencies: ${devDepCount}
+`;
+      summary += `Tools detected: ${toolList}
+
+`;
+      summary += `Created planmode.yaml and plan.md. Edit the plan content to add details, then use planmode_test to validate and planmode_publish to publish.`;
+      return textResult(summary);
+    } catch (err) {
+      return errorResult("Error creating snapshot", err);
+    }
+  }
+);
+server.registerResource(
+  "installed-packages",
+  new ResourceTemplate("planmode://packages/{name}", {
+    list: async () => {
+      const lockfile = readLockfile();
+      return {
+        resources: Object.entries(lockfile.packages).map(([name, entry]) => ({
+          uri: `planmode://packages/${name}`,
+          name: `${name} (${entry.type} v${entry.version})`,
+          description: `Installed at ${entry.installed_to}`,
+          mimeType: "text/markdown"
+        }))
+      };
+    }
+  }),
+  {
+    description: "Installed planmode packages in the current project. Each resource contains the full content of an installed plan, rule, or prompt.",
+    mimeType: "text/markdown"
+  },
+  async (uri, variables) => {
+    const name = variables["name"];
+    const lockfile = readLockfile();
+    const entry = lockfile.packages[name];
+    if (!entry) {
+      return {
+        contents: [{
+          uri: uri.href,
+          mimeType: "text/plain",
+          text: `Package '${name}' is not installed.`
+        }]
+      };
+    }
+    const fullPath = path12.join(process.cwd(), entry.installed_to);
+    let content;
+    try {
+      content = fs12.readFileSync(fullPath, "utf-8");
+    } catch {
+      content = `File not found at ${entry.installed_to}. The package may need to be reinstalled.`;
+    }
+    return {
+      contents: [{
+        uri: uri.href,
+        mimeType: "text/markdown",
+        text: content
+      }]
+    };
+  }
+);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("planmode MCP server running on stdio");
+}
+main().catch((error) => {
+  console.error("Server error:", error);
+  process.exit(1);
+});