planmode 0.2.2 → 0.4.0

package/dist/mcp.js

@@ -1,112 +1,361 @@
 #!/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";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/lib/logger.ts
-var RESET = "\x1B[0m";
-var RED = "\x1B[31m";
-var GREEN = "\x1B[32m";
-var YELLOW = "\x1B[33m";
-var CYAN = "\x1B[36m";
-var DIM = "\x1B[2m";
-var BOLD = "\x1B[1m";
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
-var capturing = false;
-var captured = [];
-var logger = {
-  capture() {
-    capturing = true;
-    captured = [];
-  },
-  flush() {
-    const messages = captured;
-    captured = [];
+var RESET, RED, GREEN, YELLOW, CYAN, DIM, BOLD, capturing, captured, logger;
+var init_logger = __esm({
+  "src/lib/logger.ts"() {
+    "use strict";
+    RESET = "\x1B[0m";
+    RED = "\x1B[31m";
+    GREEN = "\x1B[32m";
+    YELLOW = "\x1B[33m";
+    CYAN = "\x1B[36m";
+    DIM = "\x1B[2m";
+    BOLD = "\x1B[1m";
     capturing = false;
-    return messages;
-  },
-  isCapturing() {
-    return capturing;
-  },
-  info(msg) {
-    const text = `info ${msg}`;
-    if (capturing) {
-      captured.push(stripAnsi(text));
-    } else {
-      console.log(`${CYAN}info${RESET} ${msg}`);
-    }
-  },
-  success(msg) {
-    const text = `\u2713 ${msg}`;
-    if (capturing) {
-      captured.push(stripAnsi(text));
-    } else {
-      console.log(`${GREEN}\u2713${RESET} ${msg}`);
-    }
-  },
-  warn(msg) {
-    const text = `warn ${msg}`;
-    if (capturing) {
-      captured.push(stripAnsi(text));
-    } else {
-      console.log(`${YELLOW}warn${RESET} ${msg}`);
-    }
-  },
-  error(msg) {
-    const text = `error ${msg}`;
-    if (capturing) {
-      captured.push(stripAnsi(text));
-    } else {
-      console.error(`${RED}error${RESET} ${msg}`);
-    }
-  },
-  dim(msg) {
-    if (capturing) {
-      captured.push(msg);
-    } else {
-      console.log(`${DIM}${msg}${RESET}`);
-    }
-  },
-  bold(msg) {
-    if (capturing) {
-      captured.push(msg);
-    } else {
-      console.log(`${BOLD}${msg}${RESET}`);
-    }
-  },
-  table(headers, rows) {
-    const colWidths = headers.map(
-      (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length))
-    );
-    const header = headers.map((h, i) => h.toUpperCase().padEnd(colWidths[i])).join("  ");
-    if (capturing) {
-      captured.push(`  ${header}`);
-      for (const row of rows) {
-        const line = row.map((cell, i) => cell.padEnd(colWidths[i])).join("  ");
-        captured.push(`  ${line}`);
+    captured = [];
+    logger = {
+      capture() {
+        capturing = true;
+        captured = [];
+      },
+      flush() {
+        const messages = captured;
+        captured = [];
+        capturing = false;
+        return messages;
+      },
+      isCapturing() {
+        return capturing;
+      },
+      info(msg) {
+        const text2 = `info ${msg}`;
+        if (capturing) {
+          captured.push(stripAnsi(text2));
+        } else {
+          console.log(`${CYAN}info${RESET} ${msg}`);
+        }
+      },
+      success(msg) {
+        const text2 = `\u2713 ${msg}`;
+        if (capturing) {
+          captured.push(stripAnsi(text2));
+        } else {
+          console.log(`${GREEN}\u2713${RESET} ${msg}`);
+        }
+      },
+      warn(msg) {
+        const text2 = `warn ${msg}`;
+        if (capturing) {
+          captured.push(stripAnsi(text2));
+        } else {
+          console.log(`${YELLOW}warn${RESET} ${msg}`);
+        }
+      },
+      error(msg) {
+        const text2 = `error ${msg}`;
+        if (capturing) {
+          captured.push(stripAnsi(text2));
+        } 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();
+        }
       }
-    } 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}`);
+    };
+  }
+});
+
+// src/lib/context.ts
+var context_exports = {};
+__export(context_exports, {
+  addContextRepo: () => addContextRepo,
+  formatSize: () => formatSize,
+  getContextSummary: () => getContextSummary,
+  readContextIndex: () => readContextIndex,
+  reindexContext: () => reindexContext,
+  removeContextRepo: () => removeContextRepo,
+  walkDirectory: () => walkDirectory,
+  writeContextIndex: () => writeContextIndex
+});
+import fs12 from "fs";
+import path12 from "path";
+import { parse as parse4, stringify as stringify6 } from "yaml";
+function getContextPath(projectDir) {
+  return path12.join(projectDir, CONTEXT_DIR, CONTEXT_FILE);
+}
+function emptyIndex() {
+  return { version: 1, repos: [] };
+}
+function readContextIndex(projectDir = process.cwd()) {
+  const filePath = getContextPath(projectDir);
+  try {
+    const raw = fs12.readFileSync(filePath, "utf-8");
+    const data = parse4(raw);
+    return data ?? emptyIndex();
+  } catch {
+    return emptyIndex();
+  }
+}
+function writeContextIndex(index, projectDir = process.cwd()) {
+  const dirPath = path12.join(projectDir, CONTEXT_DIR);
+  fs12.mkdirSync(dirPath, { recursive: true });
+  const filePath = getContextPath(projectDir);
+  fs12.writeFileSync(filePath, stringify6(index), "utf-8");
+}
+function walkDirectory(dirPath) {
+  const files = [];
+  function walk(currentPath) {
+    let entries;
+    try {
+      entries = fs12.readdirSync(currentPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && IGNORED_DIRS.has(entry.name)) continue;
+      if (IGNORED_DIRS.has(entry.name)) continue;
+      const fullPath = path12.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path12.extname(entry.name).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
+        try {
+          const stat = fs12.statSync(fullPath);
+          const relativePath = path12.relative(dirPath, fullPath);
+          files.push({
+            path: relativePath,
+            extension: ext,
+            size: stat.size,
+            modified_at: stat.mtime.toISOString()
+          });
+        } catch {
+        }
       }
     }
-  },
-  blank() {
-    if (capturing) {
-      captured.push("");
-    } else {
-      console.log();
+  }
+  walk(dirPath);
+  return files;
+}
+function addContextRepo(repoPath, options = {}) {
+  const projectDir = options.projectDir ?? process.cwd();
+  const absolutePath = path12.resolve(projectDir, repoPath);
+  if (!fs12.existsSync(absolutePath)) {
+    throw new Error(`Directory not found: ${repoPath}`);
+  }
+  if (!fs12.statSync(absolutePath).isDirectory()) {
+    throw new Error(`Not a directory: ${repoPath}`);
+  }
+  const index = readContextIndex(projectDir);
+  const relative = path12.relative(projectDir, absolutePath);
+  const isInsideProject = !relative.startsWith("..") && !path12.isAbsolute(relative);
+  const storedPath = isInsideProject ? relative : absolutePath;
+  const existing = index.repos.find(
+    (r) => r.repo.path === storedPath || r.repo.name === options.name
+  );
+  if (existing) {
+    throw new Error(
+      `Context repo already exists: ${existing.repo.name ?? existing.repo.path}. Use \`planmode context reindex\` to refresh.`
+    );
+  }
+  logger.info(`Scanning ${absolutePath}...`);
+  const files = walkDirectory(absolutePath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const repoIndex = {
+    repo: {
+      path: storedPath,
+      name: options.name,
+      added_at: now
+    },
+    files,
+    indexed_at: now,
+    file_count: files.length,
+    total_size: files.reduce((sum, f) => sum + f.size, 0)
+  };
+  index.repos.push(repoIndex);
+  writeContextIndex(index, projectDir);
+  logger.success(`Added "${options.name ?? storedPath}" \u2014 ${files.length} file(s), ${formatSize(repoIndex.total_size)}`);
+  const breakdown = getTypeBreakdown(files);
+  if (breakdown.length > 0) {
+    logger.dim(`  ${breakdown.join(", ")}`);
+  }
+  return repoIndex;
+}
+function removeContextRepo(pathOrName, projectDir = process.cwd()) {
+  const index = readContextIndex(projectDir);
+  const idx = index.repos.findIndex(
+    (r) => r.repo.path === pathOrName || r.repo.name === pathOrName
+  );
+  if (idx === -1) {
+    throw new Error(`Context repo not found: ${pathOrName}`);
+  }
+  const removed = index.repos[idx];
+  index.repos.splice(idx, 1);
+  writeContextIndex(index, projectDir);
+  logger.success(`Removed "${removed.repo.name ?? removed.repo.path}"`);
+}
+function reindexContext(pathOrName, projectDir = process.cwd()) {
+  const index = readContextIndex(projectDir);
+  if (index.repos.length === 0) {
+    throw new Error("No context repos configured. Use `planmode context add <path>` first.");
+  }
+  const targets = pathOrName ? index.repos.filter(
+    (r) => r.repo.path === pathOrName || r.repo.name === pathOrName
+  ) : index.repos;
+  if (pathOrName && targets.length === 0) {
+    throw new Error(`Context repo not found: ${pathOrName}`);
+  }
+  for (const repo of targets) {
+    const absolutePath = path12.resolve(projectDir, repo.repo.path);
+    if (!fs12.existsSync(absolutePath)) {
+      logger.warn(`Directory not found, skipping: ${repo.repo.path}`);
+      continue;
     }
+    logger.info(`Re-scanning ${repo.repo.name ?? repo.repo.path}...`);
+    const files = walkDirectory(absolutePath);
+    repo.files = files;
+    repo.indexed_at = (/* @__PURE__ */ new Date()).toISOString();
+    repo.file_count = files.length;
+    repo.total_size = files.reduce((sum, f) => sum + f.size, 0);
+    logger.success(`Reindexed "${repo.repo.name ?? repo.repo.path}" \u2014 ${files.length} file(s), ${formatSize(repo.total_size)}`);
   }
-};
+  writeContextIndex(index, projectDir);
+}
+function getContextSummary(projectDir = process.cwd()) {
+  const index = readContextIndex(projectDir);
+  return {
+    totalRepos: index.repos.length,
+    totalFiles: index.repos.reduce((sum, r) => sum + r.file_count, 0),
+    totalSize: index.repos.reduce((sum, r) => sum + r.total_size, 0),
+    repos: index.repos.map((r) => ({
+      name: r.repo.name ?? r.repo.path,
+      path: r.repo.path,
+      fileCount: r.file_count,
+      totalSize: r.total_size,
+      typeBreakdown: getTypeBreakdown(r.files),
+      indexedAt: r.indexed_at
+    }))
+  };
+}
+function getTypeBreakdown(files) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    counts.set(file.extension, (counts.get(file.extension) ?? 0) + 1);
+  }
+  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1]).map(([ext, count]) => `${ext}: ${count}`);
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+var CONTEXT_DIR, CONTEXT_FILE, SUPPORTED_EXTENSIONS, IGNORED_DIRS;
+var init_context = __esm({
+  "src/lib/context.ts"() {
+    "use strict";
+    init_logger();
+    CONTEXT_DIR = ".planmode";
+    CONTEXT_FILE = "context.yaml";
+    SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".txt",
+      ".md",
+      ".markdown",
+      ".pdf",
+      ".rtf",
+      ".doc",
+      ".docx",
+      ".csv",
+      ".tsv",
+      ".json",
+      ".yaml",
+      ".yml",
+      ".xml",
+      ".html",
+      ".htm",
+      ".rst",
+      ".org",
+      ".tex",
+      ".log"
+    ]);
+    IGNORED_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      ".next",
+      "__pycache__",
+      ".venv",
+      "venv",
+      ".tox",
+      "target",
+      "out",
+      ".cache",
+      ".turbo",
+      "coverage",
+      ".nyc_output"
+    ]);
+  }
+});
+
+// src/mcp.ts
+init_logger();
+import fs13 from "fs";
+import path13 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/registry.ts
 import fs2 from "fs";
@@ -651,6 +900,9 @@ function coerceValue(raw, def) {
   }
 }
 
+// src/lib/installer.ts
+init_logger();
+
 // src/lib/analytics.ts
 var API_BASE = "https://api.planmode.org";
 function trackDownload(packageName) {
@@ -660,6 +912,118 @@ function trackDownload(packageName) {
   });
 }
 
+// src/lib/prompts.ts
+import * as p from "@clack/prompts";
+function isInteractive() {
+  return Boolean(process.stdin.isTTY) && !process.env.CI;
+}
+function handleCancel(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+async function promptForVariable(name, def) {
+  switch (def.type) {
+    case "enum": {
+      const value = await p.select({
+        message: def.description || name,
+        options: (def.options ?? []).map((opt) => ({
+          value: opt,
+          label: opt
+        })),
+        initialValue: def.default !== void 0 ? String(def.default) : void 0
+      });
+      return handleCancel(value);
+    }
+    case "boolean": {
+      const value = await p.confirm({
+        message: def.description || name,
+        initialValue: def.default !== void 0 ? Boolean(def.default) : false
+      });
+      return handleCancel(value);
+    }
+    case "number": {
+      const value = await p.text({
+        message: def.description || name,
+        placeholder: def.default !== void 0 ? String(def.default) : void 0,
+        defaultValue: def.default !== void 0 ? String(def.default) : void 0,
+        validate(input) {
+          if (isNaN(Number(input))) return "Must be a number";
+        }
+      });
+      return Number(handleCancel(value));
+    }
+    case "string":
+    default: {
+      const value = await p.text({
+        message: def.description || name,
+        placeholder: def.default !== void 0 ? String(def.default) : void 0,
+        defaultValue: def.default !== void 0 ? String(def.default) : void 0,
+        validate(input) {
+          if (def.required && !input) return `${name} is required`;
+        }
+      });
+      return handleCancel(value);
+    }
+  }
+}
+async function promptForVariables(variableDefs, provided, noInput = false) {
+  const values = {};
+  for (const [name, def] of Object.entries(variableDefs)) {
+    if (def.type === "resolved") continue;
+    if (provided[name] !== void 0) {
+      values[name] = coerceValue2(provided[name], def);
+    } else if (def.default !== void 0) {
+      if (isInteractive() && !noInput) {
+        values[name] = await promptForVariable(name, def);
+      } else {
+        values[name] = def.default;
+      }
+    } else if (def.required) {
+      if (isInteractive() && !noInput) {
+        values[name] = await promptForVariable(name, def);
+      } else {
+        throw new Error(`Missing required variable: ${name} -- ${def.description}`);
+      }
+    }
+  }
+  return values;
+}
+function coerceValue2(raw, def) {
+  switch (def.type) {
+    case "number":
+      return Number(raw);
+    case "boolean":
+      return raw === "true" || raw === "1" || raw === "yes";
+    case "enum":
+      if (def.options && !def.options.includes(raw)) {
+        throw new Error(
+          `Invalid value "${raw}" for enum variable. Options: ${def.options.join(", ")}`
+        );
+      }
+      return raw;
+    default:
+      return raw;
+  }
+}
+async function withSpinner(message, fn, successMessage) {
+  if (!isInteractive()) {
+    return fn();
+  }
+  const s = p.spinner();
+  s.start(message);
+  try {
+    const result = await fn();
+    s.stop(successMessage ?? message);
+    return result;
+  } catch (err) {
+    s.stop(`Failed: ${message}`);
+    throw err;
+  }
+}
+
 // src/lib/installer.ts
 function getInstallDir(type) {
   switch (type) {
@@ -679,38 +1043,60 @@ function contentHash(content) {
 }
 async function installPackage(packageName, options = {}) {
   const projectDir = options.projectDir ?? process.cwd();
+  const interactive = options.interactive ?? (isInteractive() && !options.noInput);
   const locked = getLockedVersion(packageName, projectDir);
   if (locked && !options.version) {
     logger.dim(`${packageName}@${locked.version} already installed`);
     return;
   }
-  logger.info(`Resolving ${packageName}...`);
-  const { version, metadata } = await resolveVersion(packageName, options.version);
-  const versionMeta = await fetchVersionMetadata(packageName, version);
-  logger.info(`Fetching ${packageName}@${version}...`);
-  const basePath = versionMeta.source.path ? `${versionMeta.source.path}/` : "";
-  const manifestRaw = await fetchFileAtTag(
-    versionMeta.source.repository,
-    versionMeta.source.tag,
-    `${basePath}planmode.yaml`
-  );
-  const manifest = parseManifest(manifestRaw);
-  let content;
-  if (manifest.content) {
-    content = manifest.content;
-  } else if (manifest.content_file) {
-    content = await fetchFileAtTag(
+  const resolveAndFetch = async () => {
+    const { version: version2, metadata: metadata2 } = await resolveVersion(packageName, options.version);
+    const versionMeta2 = await fetchVersionMetadata(packageName, version2);
+    return { version: version2, metadata: metadata2, versionMeta: versionMeta2 };
+  };
+  const { version, metadata, versionMeta } = interactive ? await withSpinner(
+    `Resolving ${packageName}...`,
+    resolveAndFetch,
+    `Resolved ${packageName}`
+  ) : await (async () => {
+    logger.info(`Resolving ${packageName}...`);
+    return resolveAndFetch();
+  })();
+  const fetchContent = async () => {
+    const basePath = versionMeta.source.path ? `${versionMeta.source.path}/` : "";
+    const manifestRaw = await fetchFileAtTag(
       versionMeta.source.repository,
       versionMeta.source.tag,
-      `${basePath}${manifest.content_file}`
+      `${basePath}planmode.yaml`
     );
-  } else {
-    throw new Error("Package has no content or content_file");
-  }
+    const manifest2 = parseManifest(manifestRaw);
+    let content2;
+    if (manifest2.content) {
+      content2 = manifest2.content;
+    } else if (manifest2.content_file) {
+      content2 = await fetchFileAtTag(
+        versionMeta.source.repository,
+        versionMeta.source.tag,
+        `${basePath}${manifest2.content_file}`
+      );
+    } else {
+      throw new Error("Package has no content or content_file");
+    }
+    return { manifest: manifest2, content: content2 };
+  };
+  const { manifest, content: rawContent } = interactive ? await withSpinner(
+    `Fetching ${packageName}@${version}...`,
+    fetchContent,
+    `Fetched ${packageName}@${version}`
+  ) : await (async () => {
+    logger.info(`Fetching ${packageName}@${version}...`);
+    return fetchContent();
+  })();
+  let content = rawContent;
   if (manifest.variables && Object.keys(manifest.variables).length > 0) {
     const provided = options.variables ?? {};
-    if (options.noInput) {
-      const values = collectVariableValues(manifest.variables, provided);
+    if (interactive) {
+      const values = await promptForVariables(manifest.variables, provided, false);
       content = renderTemplate(content, values);
     } else {
       const values = collectVariableValues(manifest.variables, provided);
@@ -772,7 +1158,8 @@ async function installPackage(packageName, options = {}) {
       await installPackage(name, {
         version: range === "*" ? void 0 : range,
         projectDir,
-        noInput: options.noInput
+        noInput: options.noInput,
+        interactive: options.interactive
       });
     }
   }
@@ -917,141 +1304,154 @@ function createPackage(options) {
 }
 
 // src/lib/publisher.ts
+init_logger();
 async function publishPackage(options = {}) {
   const cwd = options.projectDir ?? process.cwd();
+  const interactive = options.interactive ?? false;
   const token = options.token ?? getGitHubToken();
   if (!token) {
     throw new Error("Not authenticated. Run `planmode login` first.");
   }
-  logger.info("Reading planmode.yaml...");
-  const manifest = readManifest(cwd);
-  const errors = validateManifest(manifest, true);
-  if (errors.length > 0) {
-    throw new Error(`Invalid manifest:
+  const doValidate = async () => {
+    const manifest2 = readManifest(cwd);
+    const errors = validateManifest(manifest2, true);
+    if (errors.length > 0) {
+      throw new Error(`Invalid manifest:
 ${errors.map((e) => `  - ${e}`).join("\n")}`);
-  }
+    }
+    return manifest2;
+  };
+  const manifest = interactive ? await withSpinner("Validating manifest...", doValidate, "Manifest valid") : await (async () => {
+    logger.info("Reading planmode.yaml...");
+    return doValidate();
+  })();
   const remoteUrl = await getRemoteUrl(cwd);
   if (!remoteUrl) {
     throw new Error("No git remote found. Push your code to GitHub first.");
   }
   const sha = await getHeadSha(cwd);
   const tag = `v${manifest.version}`;
-  logger.info(`Creating tag ${tag}...`);
-  try {
-    await createTag(cwd, tag);
-  } catch {
-    logger.dim(`Tag ${tag} already exists, using existing`);
-  }
-  try {
-    await pushTag(cwd, tag);
+  const doTag = async () => {
+    try {
+      await createTag(cwd, tag);
+    } catch {
+    }
+    try {
+      await pushTag(cwd, tag);
+    } catch {
+    }
+  };
+  if (interactive) {
+    await withSpinner(`Creating tag ${tag}...`, doTag, `Tag ${tag} ready`);
+  } else {
+    logger.info(`Creating tag ${tag}...`);
+    await doTag();
     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: {
+  const doSubmit = async () => {
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "planmode-cli",
+      "Content-Type": "application/json"
+    };
+    await fetch("https://api.github.com/repos/kaihannonen/planmode.org/forks", {
+      method: "POST",
+      headers
+    });
+    const userRes = await fetch("https://api.github.com/user", { headers });
+    if (!userRes.ok) {
+      throw new Error("Failed to authenticate with GitHub. Check your token.");
+    }
+    const user = await userRes.json();
+    const repoPath = remoteUrl.replace(/^https?:\/\//, "").replace(/\.git$/, "");
+    const metadataContent = JSON.stringify(
+      {
+        name: manifest.name,
+        description: manifest.description,
+        author: manifest.author,
+        license: manifest.license,
         repository: repoPath,
-        tag,
-        sha
+        category: manifest.category ?? "other",
+        tags: manifest.tags ?? [],
+        type: manifest.type,
+        models: manifest.models ?? [],
+        latest_version: manifest.version,
+        versions: [manifest.version],
+        downloads: 0,
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        dependencies: manifest.dependencies,
+        variables: manifest.variables
       },
-      files: ["planmode.yaml", manifest.content_file ?? "inline"],
-      content_hash: `sha256:${sha.slice(0, 16)}`
-    },
-    null,
-    2
-  );
-  const branchName = `add-${manifest.name}-${manifest.version}`;
-  const refRes = await fetch(
-    `https://api.github.com/repos/${user.login}/planmode.org/git/ref/heads/main`,
-    { headers }
-  );
-  if (!refRes.ok) {
-    throw new Error("Failed to access registry fork. Make sure the fork exists.");
-  }
-  const refData = await refRes.json();
-  const baseSha = refData.object.sha;
-  await fetch(`https://api.github.com/repos/${user.login}/planmode.org/git/refs`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({
-      ref: `refs/heads/${branchName}`,
-      sha: baseSha
-    })
-  });
-  await fetch(
-    `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/metadata.json`,
-    {
-      method: "PUT",
+      null,
+      2
+    );
+    const versionContent = JSON.stringify(
+      {
+        version: manifest.version,
+        published_at: (/* @__PURE__ */ new Date()).toISOString(),
+        source: {
+          repository: repoPath,
+          tag,
+          sha
+        },
+        files: ["planmode.yaml", manifest.content_file ?? "inline"],
+        content_hash: `sha256:${sha.slice(0, 16)}`
+      },
+      null,
+      2
+    );
+    const branchName = `add-${manifest.name}-${manifest.version}`;
+    const refRes = await fetch(
+      `https://api.github.com/repos/${user.login}/planmode.org/git/ref/heads/main`,
+      { headers }
+    );
+    if (!refRes.ok) {
+      throw new Error("Failed to access registry fork. Make sure the fork exists.");
+    }
+    const refData = await refRes.json();
+    const baseSha = refData.object.sha;
+    await fetch(`https://api.github.com/repos/${user.login}/planmode.org/git/refs`, {
+      method: "POST",
       headers,
       body: JSON.stringify({
-        message: `Add ${manifest.name}@${manifest.version}`,
-        content: Buffer.from(metadataContent).toString("base64"),
-        branch: branchName
+        ref: `refs/heads/${branchName}`,
+        sha: baseSha
       })
-    }
-  );
-  await fetch(
-    `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/versions/${manifest.version}.json`,
-    {
-      method: "PUT",
+    });
+    await fetch(
+      `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/metadata.json`,
+      {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({
+          message: `Add ${manifest.name}@${manifest.version}`,
+          content: Buffer.from(metadataContent).toString("base64"),
+          branch: branchName
+        })
+      }
+    );
+    await fetch(
+      `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/versions/${manifest.version}.json`,
+      {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({
+          message: `Add ${manifest.name}@${manifest.version} version metadata`,
+          content: Buffer.from(versionContent).toString("base64"),
+          branch: branchName
+        })
+      }
+    );
+    const prRes = await fetch("https://api.github.com/repos/kaihannonen/planmode.org/pulls", {
+      method: "POST",
       headers,
       body: JSON.stringify({
-        message: `Add ${manifest.name}@${manifest.version} version metadata`,
-        content: Buffer.from(versionContent).toString("base64"),
-        branch: branchName
-      })
-    }
-  );
-  const prRes = await fetch("https://api.github.com/repos/kaihannonen/planmode.org/pulls", {
-    method: "POST",
-    headers,
-    body: JSON.stringify({
-      title: `Add ${manifest.name}@${manifest.version}`,
-      head: `${user.login}:${branchName}`,
-      base: "main",
-      body: `## New package: ${manifest.name}
+        title: `Add ${manifest.name}@${manifest.version}`,
+        head: `${user.login}:${branchName}`,
+        base: "main",
+        body: `## New package: ${manifest.name}
 
 - **Type:** ${manifest.type}
 - **Version:** ${manifest.version}
@@ -1059,17 +1459,30 @@ ${errors.map((e) => `  - ${e}`).join("\n")}`);
 - **Author:** ${manifest.author}
 
 Submitted via \`planmode publish\`.`
-    })
-  });
-  if (!prRes.ok) {
-    const err = await prRes.text();
-    throw new Error(`Failed to create PR: ${err}`);
+      })
+    });
+    if (!prRes.ok) {
+      const err = await prRes.text();
+      throw new Error(`Failed to create PR: ${err}`);
+    }
+    const pr = await prRes.json();
+    return pr.html_url;
+  };
+  let prUrl;
+  if (interactive) {
+    prUrl = await withSpinner(
+      "Submitting to registry...",
+      doSubmit,
+      "Submitted to registry"
+    );
+  } else {
+    logger.info("Submitting to registry...");
+    prUrl = await doSubmit();
+    logger.success(`Published ${manifest.name}@${manifest.version}`);
+    logger.info(`PR: ${prUrl}`);
   }
-  const pr = await prRes.json();
-  logger.success(`Published ${manifest.name}@${manifest.version}`);
-  logger.info(`PR: ${pr.html_url}`);
   return {
-    prUrl: pr.html_url,
+    prUrl,
     packageName: manifest.name,
     version: manifest.version
   };
@@ -1692,6 +2105,7 @@ function detectCategory(data) {
 }
 
 // src/mcp.ts
+init_context();
 function withCapture(fn) {
   logger.capture();
   try {
@@ -1714,9 +2128,9 @@ async function withCaptureAsync(fn) {
     throw Object.assign(err, { capturedMessages: messages });
   }
 }
-function textResult(text, isError = false) {
+function textResult(text2, isError = false) {
   return {
-    content: [{ type: "text", text }],
+    content: [{ type: "text", text: text2 }],
     isError
   };
 }
@@ -1969,14 +2383,14 @@ server.registerTool(
       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`)
+          path13.join(dir, "plans", `${packageName}.md`),
+          path13.join(dir, ".claude", "rules", `${packageName}.md`),
+          path13.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);
+          if (fs13.existsSync(candidate)) {
+            const content2 = fs13.readFileSync(candidate, "utf-8");
+            const relativePath = path13.relative(dir, candidate);
             return textResult(`# ${packageName}
 **Location:** ${relativePath}
 
@@ -1990,14 +2404,14 @@ ${content2}`);
           true
         );
       }
-      const fullPath = path12.join(dir, entry.installed_to);
-      if (!fs12.existsSync(fullPath)) {
+      const fullPath = path13.join(dir, entry.installed_to);
+      if (!fs13.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");
+      const content = fs13.readFileSync(fullPath, "utf-8");
       return textResult(
         `# ${packageName} (${entry.type} v${entry.version})
 **Location:** ${entry.installed_to}
@@ -2184,17 +2598,17 @@ server.registerTool(
   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");
+      const localPath = path13.join(dir, "prompts", `${promptName}.md`);
+      const localManifestPath = path13.join(dir, "prompts", promptName, "planmode.yaml");
       let content;
       let manifest;
-      if (fs12.existsSync(localManifestPath)) {
-        const raw = fs12.readFileSync(localManifestPath, "utf-8");
+      if (fs13.existsSync(localManifestPath)) {
+        const raw = fs13.readFileSync(localManifestPath, "utf-8");
         manifest = parseManifest(raw);
-        const promptDir = path12.join(dir, "prompts", promptName);
+        const promptDir = path13.join(dir, "prompts", promptName);
         content = readPackageContent(promptDir, manifest);
-      } else if (fs12.existsSync(localPath)) {
-        content = fs12.readFileSync(localPath, "utf-8");
+      } else if (fs13.existsSync(localPath)) {
+        content = fs13.readFileSync(localPath, "utf-8");
       } else {
         return textResult(
           `Prompt '${promptName}' not found locally. Install it first using the planmode_install tool.`,
@@ -2376,6 +2790,128 @@ server.registerTool(
     }
   }
 );
+server.registerTool(
+  "planmode_context_add",
+  {
+    description: "Add a document directory to the project context. Indexes all text-based files (md, pdf, txt, json, yaml, csv, html, etc.) and stores their metadata in .planmode/context.yaml. The AI can then see what documents are available and read them on demand.",
+    inputSchema: {
+      path: z.string().describe("Path to the document directory (relative to project or absolute)"),
+      name: z.string().optional().describe("Human-readable label for this directory"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ path: dirPath, name, projectDir }) => {
+    try {
+      const { result, messages } = withCapture(
+        () => addContextRepo(dirPath, { name, projectDir })
+      );
+      const breakdown = result.files.length > 0 ? `
+Types: ${getTypeBreakdownText(result)}` : "";
+      return textResult(
+        formatMessages(
+          messages,
+          `Added "${name ?? result.repo.path}" \u2014 ${result.file_count} file(s), ${formatSize(result.total_size)}${breakdown}`
+        )
+      );
+    } catch (err) {
+      return errorResult("Error adding context repo", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_context_remove",
+  {
+    description: "Remove a document directory from the project context",
+    inputSchema: {
+      pathOrName: z.string().describe("Path or name of the context repo to remove"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ pathOrName, projectDir }) => {
+    try {
+      const { messages } = withCapture(
+        () => removeContextRepo(pathOrName, projectDir)
+      );
+      return textResult(formatMessages(messages) || `Removed "${pathOrName}" from context.`);
+    } catch (err) {
+      return errorResult("Error removing context repo", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_context_list",
+  {
+    description: "List all document directories in the project context with file counts, sizes, and type breakdowns. Use this to see what reference documents are available for the project.",
+    inputSchema: {
+      detailed: z.boolean().optional().describe("Include full file listings for each repo (default: false, shows only summaries)"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ detailed, projectDir }) => {
+    try {
+      const summary = getContextSummary(projectDir);
+      if (summary.totalRepos === 0) {
+        return textResult("No context repos configured. Use planmode_context_add to add a document directory.");
+      }
+      const lines = [
+        `**${summary.totalRepos} context repo(s)** \u2014 ${summary.totalFiles} file(s), ${formatSize(summary.totalSize)}`,
+        ""
+      ];
+      for (const repo of summary.repos) {
+        lines.push(`### ${repo.name}`);
+        lines.push(`- **Path:** ${repo.path}`);
+        lines.push(`- **Files:** ${repo.fileCount} (${formatSize(repo.totalSize)})`);
+        if (repo.typeBreakdown.length > 0) {
+          lines.push(`- **Types:** ${repo.typeBreakdown.join(", ")}`);
+        }
+        lines.push(`- **Indexed:** ${repo.indexedAt}`);
+        if (detailed) {
+          const index = (await Promise.resolve().then(() => (init_context(), context_exports))).readContextIndex(projectDir);
+          const repoIndex = index.repos.find(
+            (r) => r.repo.path === repo.path || r.repo.name === repo.name
+          );
+          if (repoIndex && repoIndex.files.length > 0) {
+            lines.push("", "**Files:**");
+            for (const file of repoIndex.files) {
+              lines.push(`- \`${file.path}\` (${file.extension}, ${formatSize(file.size)})`);
+            }
+          }
+        }
+        lines.push("");
+      }
+      return textResult(lines.join("\n"));
+    } catch (err) {
+      return errorResult("Error listing context", err);
+    }
+  }
+);
+server.registerTool(
+  "planmode_context_reindex",
+  {
+    description: "Re-scan files in one or all context directories to update the file index",
+    inputSchema: {
+      pathOrName: z.string().optional().describe("Path or name of a specific repo to reindex (omit to reindex all)"),
+      projectDir: z.string().optional().describe("Project directory (default: current working directory)")
+    }
+  },
+  async ({ pathOrName, projectDir }) => {
+    try {
+      const { messages } = withCapture(
+        () => reindexContext(pathOrName, projectDir)
+      );
+      return textResult(formatMessages(messages) || "Reindex complete.");
+    } catch (err) {
+      return errorResult("Error reindexing context", err);
+    }
+  }
+);
+function getTypeBreakdownText(repoIndex) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of repoIndex.files) {
+    counts.set(file.extension, (counts.get(file.extension) ?? 0) + 1);
+  }
+  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1]).map(([ext, count]) => `${ext}: ${count}`).join(", ");
+}
 server.registerResource(
   "installed-packages",
   new ResourceTemplate("planmode://packages/{name}", {
@@ -2408,10 +2944,10 @@ server.registerResource(
         }]
       };
     }
-    const fullPath = path12.join(process.cwd(), entry.installed_to);
+    const fullPath = path13.join(process.cwd(), entry.installed_to);
     let content;
     try {
-      content = fs12.readFileSync(fullPath, "utf-8");
+      content = fs13.readFileSync(fullPath, "utf-8");
     } catch {
       content = `File not found at ${entry.installed_to}. The package may need to be reinstalled.`;
     }