planmode 0.1.0

package/dist/index.js

@@ -0,0 +1,1293 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command11 } 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";
+
+// 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 writeConfig(config) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, stringify(config), "utf-8");
+}
+function getGitHubToken() {
+  const envToken = process.env["PLANMODE_GITHUB_TOKEN"];
+  if (envToken) return envToken;
+  const config = readConfig();
+  return config.auth?.github_token;
+}
+function setGitHubToken(token) {
+  const config = readConfig();
+  config.auth = { ...config.auth, github_token: token };
+  writeConfig(config);
+}
+function getRegistries() {
+  const config = readConfig();
+  return {
+    default: "github.com/planmode/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}`);
+  }
+  return `https://raw.githubusercontent.com/${match[1]}/${match[2]}/main/${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/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");
+}
+
+// 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;
+  }
+}
+async function resolveVariable(def, currentValues) {
+  if (def.type !== "resolved" || !def.source) {
+    throw new Error("resolveVariable called on non-resolved variable");
+  }
+  const sourceUrl = renderTemplate(def.source, currentValues);
+  const response = await fetch(sourceUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to resolve variable from ${sourceUrl}: ${response.status}`);
+  }
+  const data = await response.json();
+  if (def.extract) {
+    return extractPath(data, def.extract);
+  }
+  return String(data);
+}
+function extractPath(obj, pathStr) {
+  const parts = pathStr.match(/[^.[\]]+/g);
+  if (!parts) return String(obj);
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return "";
+    if (typeof current === "object") {
+      current = current[part];
+    }
+  }
+  return String(current ?? "");
+}
+
+// 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";
+var logger = {
+  info(msg) {
+    console.log(`${CYAN}info${RESET} ${msg}`);
+  },
+  success(msg) {
+    console.log(`${GREEN}\u2713${RESET} ${msg}`);
+  },
+  warn(msg) {
+    console.log(`${YELLOW}warn${RESET} ${msg}`);
+  },
+  error(msg) {
+    console.error(`${RED}error${RESET} ${msg}`);
+  },
+  dim(msg) {
+    console.log(`${DIM}${msg}${RESET}`);
+  },
+  bold(msg) {
+    console.log(`${BOLD}${msg}${RESET}`);
+  },
+  table(headers, rows) {
+    const colWidths = headers.map(
+      (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length))
+    );
+    const header = headers.map((h, i) => h.toUpperCase().padEnd(colWidths[i])).join("  ");
+    console.log(`  ${DIM}${header}${RESET}`);
+    for (const row of rows) {
+      const line = row.map((cell, i) => cell.padEnd(colWidths[i])).join("  ");
+      console.log(`  ${line}`);
+    }
+  },
+  blank() {
+    console.log();
+  }
+};
+
+// 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 manifestRaw = await fetchFileAtTag(
+    versionMeta.source.repository,
+    versionMeta.source.tag,
+    "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,
+      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`);
+    }
+  }
+  fs7.mkdirSync(path7.dirname(fullPath), { recursive: true });
+  fs7.writeFileSync(fullPath, content, "utf-8");
+  logger.success(`Installed ${packageName}@${version} \u2192 ${installPath}`);
+  if (type === "plan") {
+    addImport(packageName, projectDir);
+    logger.dim(`Added @import to CLAUDE.md`);
+  }
+  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/commands/install.ts
+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").action(
+  async (packageName, options) => {
+    try {
+      logger.blank();
+      await installPackage(packageName, {
+        version: options.version,
+        forceRule: options.rule,
+        noInput: options.input === false
+      });
+      logger.blank();
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  }
+);
+
+// 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);
+  }
+});
+
+// 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.");
+      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
+      ])
+    );
+    logger.blank();
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/run.ts
+import { Command as Command4 } from "commander";
+import fs8 from "fs";
+import path8 from "path";
+var runCommand = new Command4("run").description("Run a templated prompt and output to stdout").argument("<prompt>", "Prompt package name").option("--no-input", "Fail if any required variable is missing").option("--json", "Output as JSON").allowUnknownOption(true).action(async (promptName, options, cmd) => {
+  try {
+    const vars = {};
+    const rawArgs = cmd.args.slice(0);
+    for (let i = 0; i < rawArgs.length; i++) {
+      const arg = rawArgs[i];
+      if (arg.startsWith("--") && arg !== "--no-input" && arg !== "--json") {
+        const key = arg.slice(2);
+        const value = rawArgs[i + 1];
+        if (value && !value.startsWith("--")) {
+          vars[key] = value;
+          i++;
+        }
+      }
+    }
+    const localPath = path8.join(process.cwd(), "prompts", `${promptName}.md`);
+    const localManifestPath = path8.join(process.cwd(), "prompts", promptName, "planmode.yaml");
+    let content;
+    let manifest;
+    if (fs8.existsSync(localManifestPath)) {
+      const raw = fs8.readFileSync(localManifestPath, "utf-8");
+      manifest = parseManifest(raw);
+      const dir = path8.join(process.cwd(), "prompts", promptName);
+      content = readPackageContent(dir, manifest);
+    } else if (fs8.existsSync(localPath)) {
+      content = fs8.readFileSync(localPath, "utf-8");
+    } else {
+      logger.error(`Prompt '${promptName}' not found locally. Install it first: planmode install ${promptName}`);
+      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);
+        }
+      }
+      for (const [name, def] of Object.entries(manifest.variables)) {
+        if (def.type !== "resolved") continue;
+        values[name] = await resolveVariable(def, values);
+      }
+      content = renderTemplate(content, values);
+      if (options.json) {
+        console.log(JSON.stringify({ rendered: content, variables: values }, null, 2));
+        return;
+      }
+    }
+    process.stdout.write(content);
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/publish.ts
+import { Command as Command5 } from "commander";
+var publishCommand = new Command5("publish").description("Publish the current directory as a package to the registry").action(async () => {
+  try {
+    const cwd = process.cwd();
+    const token = getGitHubToken();
+    if (!token) {
+      logger.error("Not authenticated. Run `planmode login` first.");
+      process.exit(1);
+    }
+    logger.info("Reading planmode.yaml...");
+    const manifest = readManifest(cwd);
+    const errors = validateManifest(manifest, true);
+    if (errors.length > 0) {
+      logger.error("Invalid manifest:");
+      for (const err of errors) {
+        console.log(`  - ${err}`);
+      }
+      process.exit(1);
+    }
+    const remoteUrl = await getRemoteUrl(cwd);
+    if (!remoteUrl) {
+      logger.error("No git remote found. Push your code to GitHub first.");
+      process.exit(1);
+    }
+    const sha = await getHeadSha(cwd);
+    const tag = `v${manifest.version}`;
+    logger.info(`Creating tag ${tag}...`);
+    try {
+      await createTag(cwd, tag);
+    } catch {
+      logger.dim(`Tag ${tag} already exists, using existing`);
+    }
+    try {
+      await pushTag(cwd, tag);
+      logger.success(`Pushed tag ${tag}`);
+    } catch {
+      logger.dim(`Tag ${tag} already pushed`);
+    }
+    logger.info("Submitting to registry...");
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "planmode-cli",
+      "Content-Type": "application/json"
+    };
+    await fetch("https://api.github.com/repos/planmode/registry/forks", {
+      method: "POST",
+      headers
+    });
+    const userRes = await fetch("https://api.github.com/user", { headers });
+    const user = await userRes.json();
+    const metadataContent = JSON.stringify(
+      {
+        name: manifest.name,
+        description: manifest.description,
+        author: manifest.author,
+        license: manifest.license,
+        repository: remoteUrl.replace(/^https?:\/\//, "").replace(/\.git$/, ""),
+        category: manifest.category ?? "other",
+        tags: manifest.tags ?? [],
+        type: manifest.type,
+        models: manifest.models ?? [],
+        latest_version: manifest.version,
+        versions: [manifest.version],
+        downloads: 0,
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        dependencies: manifest.dependencies,
+        variables: manifest.variables
+      },
+      null,
+      2
+    );
+    const versionContent = JSON.stringify(
+      {
+        version: manifest.version,
+        published_at: (/* @__PURE__ */ new Date()).toISOString(),
+        source: {
+          repository: remoteUrl.replace(/^https?:\/\//, "").replace(/\.git$/, ""),
+          tag,
+          sha
+        },
+        files: ["planmode.yaml", manifest.content_file ?? "inline"],
+        content_hash: `sha256:${sha.slice(0, 16)}`
+      },
+      null,
+      2
+    );
+    const branchName = `add-${manifest.name}-${manifest.version}`;
+    const refRes = await fetch(
+      `https://api.github.com/repos/${user.login}/registry/git/ref/heads/main`,
+      { headers }
+    );
+    if (!refRes.ok) {
+      logger.error("Failed to access registry fork. Make sure the fork exists.");
+      process.exit(1);
+    }
+    const refData = await refRes.json();
+    const baseSha = refData.object.sha;
+    await fetch(`https://api.github.com/repos/${user.login}/registry/git/refs`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        ref: `refs/heads/${branchName}`,
+        sha: baseSha
+      })
+    });
+    await fetch(
+      `https://api.github.com/repos/${user.login}/registry/contents/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}/registry/contents/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/planmode/registry/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 pr = await prRes.json();
+      logger.blank();
+      logger.success(`Published ${manifest.name}@${manifest.version}`);
+      logger.info(`PR: ${pr.html_url}`);
+    } else {
+      const err = await prRes.text();
+      logger.error(`Failed to create PR: ${err}`);
+      process.exit(1);
+    }
+    logger.blank();
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/update.ts
+import { Command as Command6 } from "commander";
+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();
+    if (packageName) {
+      const updated = await updatePackage(packageName);
+      if (!updated) {
+        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.");
+        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}`);
+        }
+      }
+      if (updatedCount === 0) {
+        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(", ")}`);
+        }
+      }
+    }
+    logger.blank();
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/init.ts
+import { Command as Command9 } from "commander";
+import fs9 from "fs";
+import path9 from "path";
+import { stringify as stringify3 } from "yaml";
+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 () => {
+  try {
+    logger.blank();
+    logger.bold("Initialize a new Planmode package");
+    logger.blank();
+    const name = await prompt("Package name: ");
+    if (!name) {
+      logger.error("Package name is required.");
+      process.exit(1);
+    }
+    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 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);
+    fs9.writeFileSync(path9.join(process.cwd(), "planmode.yaml"), yamlContent, "utf-8");
+    logger.success("Created planmode.yaml");
+    const stubs = {
+      plan: `# ${name}
+
+1. First step
+2. Second step
+3. Third step
+`,
+      rule: `- Rule one
+- Rule two
+- Rule three
+`,
+      prompt: `Write your prompt here.
+
+Use {{variable_name}} for template variables.
+`
+    };
+    fs9.writeFileSync(
+      path9.join(process.cwd(), contentFile),
+      stubs[type] ?? stubs["plan"],
+      "utf-8"
+    );
+    logger.success(`Created ${contentFile}`);
+    logger.blank();
+    logger.info(`Edit ${contentFile}, then run \`planmode publish\` when ready.`);
+    logger.blank();
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/login.ts
+import { Command as Command10 } from "commander";
+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;
+  if (options.token) {
+    token = options.token;
+  } else if (options.gh) {
+    try {
+      token = execSync("gh auth token", { encoding: "utf-8" }).trim();
+    } catch {
+      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());
+      });
+    });
+  }
+  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"
+    }
+  });
+  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/index.ts
+var program = new Command11();
+program.name("planmode").description("The open source package manager for AI plans, rules, and prompts.").version("0.1.0");
+program.addCommand(installCommand);
+program.addCommand(uninstallCommand);
+program.addCommand(searchCommand);
+program.addCommand(runCommand);
+program.addCommand(publishCommand);
+program.addCommand(updateCommand);
+program.addCommand(listCommand);
+program.addCommand(infoCommand);
+program.addCommand(initCommand);
+program.addCommand(loginCommand);
+program.parse();