planmode 0.3.0 → 0.4.0

package/dist/index.js

@@ -1377,18 +1377,240 @@ var init_doctor = __esm({
   }
 });
 
+// src/lib/context.ts
+import fs15 from "fs";
+import path15 from "path";
+import { parse as parse4, stringify as stringify6 } from "yaml";
+function getContextPath(projectDir) {
+  return path15.join(projectDir, CONTEXT_DIR, CONTEXT_FILE);
+}
+function emptyIndex() {
+  return { version: 1, repos: [] };
+}
+function readContextIndex(projectDir = process.cwd()) {
+  const filePath = getContextPath(projectDir);
+  try {
+    const raw = fs15.readFileSync(filePath, "utf-8");
+    const data = parse4(raw);
+    return data ?? emptyIndex();
+  } catch {
+    return emptyIndex();
+  }
+}
+function writeContextIndex(index, projectDir = process.cwd()) {
+  const dirPath = path15.join(projectDir, CONTEXT_DIR);
+  fs15.mkdirSync(dirPath, { recursive: true });
+  const filePath = getContextPath(projectDir);
+  fs15.writeFileSync(filePath, stringify6(index), "utf-8");
+}
+function walkDirectory(dirPath) {
+  const files = [];
+  function walk(currentPath) {
+    let entries;
+    try {
+      entries = fs15.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 = path15.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path15.extname(entry.name).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
+        try {
+          const stat = fs15.statSync(fullPath);
+          const relativePath = path15.relative(dirPath, fullPath);
+          files.push({
+            path: relativePath,
+            extension: ext,
+            size: stat.size,
+            modified_at: stat.mtime.toISOString()
+          });
+        } catch {
+        }
+      }
+    }
+  }
+  walk(dirPath);
+  return files;
+}
+function addContextRepo(repoPath, options = {}) {
+  const projectDir = options.projectDir ?? process.cwd();
+  const absolutePath = path15.resolve(projectDir, repoPath);
+  if (!fs15.existsSync(absolutePath)) {
+    throw new Error(`Directory not found: ${repoPath}`);
+  }
+  if (!fs15.statSync(absolutePath).isDirectory()) {
+    throw new Error(`Not a directory: ${repoPath}`);
+  }
+  const index = readContextIndex(projectDir);
+  const relative = path15.relative(projectDir, absolutePath);
+  const isInsideProject = !relative.startsWith("..") && !path15.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 = path15.resolve(projectDir, repo.repo.path);
+    if (!fs15.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/commands/interactive.ts
 var interactive_exports = {};
 __export(interactive_exports, {
   runInteractiveMenu: () => runInteractiveMenu
 });
-import fs15 from "fs";
-import path15 from "path";
+import fs16 from "fs";
+import path16 from "path";
 import os3 from "os";
 import * as p12 from "@clack/prompts";
 function isFirstRun() {
-  const configPath = path15.join(os3.homedir(), ".planmode", "config");
-  const hasConfig = fs15.existsSync(configPath);
+  const configPath = path16.join(os3.homedir(), ".planmode", "config");
+  const hasConfig = fs16.existsSync(configPath);
   const lockfile = readLockfile();
   const hasPackages = Object.keys(lockfile.packages).length > 0;
   return !hasConfig && !hasPackages;
@@ -1517,6 +1739,7 @@ async function mainMenu() {
           { value: "install", label: "Install a package", hint: "install by name" },
           { value: "create", label: "Create a new package" },
           { value: "list", label: "My installed packages" },
+          { value: "context", label: "Manage context", hint: "document directories for AI" },
           { value: "doctor", label: "Health check" },
           { value: "exit", label: "Exit" }
         ]
@@ -1540,6 +1763,9 @@ async function mainMenu() {
       case "list":
         listFlow();
         break;
+      case "context":
+        await contextFlow();
+        break;
       case "doctor":
         doctorFlow();
         break;
@@ -1697,6 +1923,94 @@ async function installFlow() {
     p12.log.error(err.message);
   }
 }
+async function contextFlow() {
+  const summary = getContextSummary();
+  if (summary.totalRepos === 0) {
+    p12.log.info("No context repos yet.");
+  } else {
+    const lines = summary.repos.map(
+      (r) => `${r.name} \u2014 ${r.fileCount} file(s), ${formatSize(r.totalSize)}`
+    );
+    p12.note(lines.join("\n"), `${summary.totalRepos} context repo(s)`);
+  }
+  const action = handleCancel(
+    await p12.select({
+      message: "What would you like to do?",
+      options: [
+        { value: "add", label: "Add a directory" },
+        { value: "remove", label: "Remove a directory" },
+        { value: "reindex", label: "Re-index all" },
+        { value: "back", label: "Back" }
+      ]
+    })
+  );
+  if (action === "back") return;
+  if (action === "add") {
+    const dirPath = handleCancel(
+      await p12.text({
+        message: "Path to document directory:",
+        placeholder: "e.g. docs, specs, ./reference",
+        validate(input) {
+          if (!input) return "Please enter a directory path";
+        }
+      })
+    );
+    const name = handleCancel(
+      await p12.text({
+        message: "Label (optional):",
+        placeholder: "e.g. Project Documentation"
+      })
+    );
+    try {
+      await withSpinner(
+        "Indexing documents...",
+        async () => addContextRepo(dirPath, { name: name || void 0 }),
+        "Indexing complete"
+      );
+    } catch (err) {
+      p12.log.error(err.message);
+    }
+  } else if (action === "remove") {
+    if (summary.totalRepos === 0) {
+      p12.log.warn("No context repos to remove.");
+      return;
+    }
+    const selected = handleCancel(
+      await p12.select({
+        message: "Select a repo to remove:",
+        options: [
+          ...summary.repos.map((r) => ({
+            value: r.name,
+            label: r.name,
+            hint: `${r.fileCount} files, ${formatSize(r.totalSize)}`
+          })),
+          { value: "__back__", label: "Back" }
+        ]
+      })
+    );
+    if (selected === "__back__") return;
+    try {
+      removeContextRepo(selected);
+      p12.log.success(`Removed "${selected}"`);
+    } catch (err) {
+      p12.log.error(err.message);
+    }
+  } else if (action === "reindex") {
+    if (summary.totalRepos === 0) {
+      p12.log.warn("No context repos to reindex.");
+      return;
+    }
+    try {
+      await withSpinner(
+        "Re-scanning documents...",
+        async () => reindexContext(),
+        "Reindex complete"
+      );
+    } catch (err) {
+      p12.log.error(err.message);
+    }
+  }
+}
 function listFlow() {
   const lockfile = readLockfile();
   const entries = Object.entries(lockfile.packages);
@@ -1738,6 +2052,7 @@ var init_interactive = __esm({
     init_installer();
     init_lockfile();
     init_doctor();
+    init_context();
     CATEGORIES2 = [
       "frontend",
       "backend",
@@ -1754,7 +2069,7 @@ var init_interactive = __esm({
 });
 
 // src/index.ts
-import { Command as Command16 } from "commander";
+import { Command as Command17 } from "commander";
 
 // src/commands/install.ts
 init_installer();
@@ -3243,10 +3558,95 @@ var snapshotCommand = new Command15("snapshot").description("Analyze the current
   }
 });
 
+// src/commands/context.ts
+init_context();
+init_logger();
+init_prompts();
+import { Command as Command16 } from "commander";
+var contextCommand = new Command16("context").description("Manage project document context for AI");
+contextCommand.command("add <path>").description("Add a document directory to the project context").option("--name <name>", "Human-readable label for this directory").action(async (dirPath, options) => {
+  try {
+    const interactive = isInteractive();
+    if (interactive) {
+      await withSpinner(
+        "Indexing documents...",
+        async () => addContextRepo(dirPath, { name: options.name }),
+        "Indexing complete"
+      );
+    } else {
+      logger.blank();
+      addContextRepo(dirPath, { name: options.name });
+      logger.blank();
+    }
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+contextCommand.command("remove <path-or-name>").description("Remove a directory from the project context").action((pathOrName) => {
+  try {
+    logger.blank();
+    removeContextRepo(pathOrName);
+    logger.blank();
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+contextCommand.command("list").description("Show all directories in the project context").option("--json", "Output as JSON").action((options) => {
+  try {
+    const summary = getContextSummary();
+    if (options.json) {
+      console.log(JSON.stringify(summary, null, 2));
+      return;
+    }
+    logger.blank();
+    if (summary.totalRepos === 0) {
+      logger.info("No context repos configured. Run `planmode context add <path>` to add one.");
+      logger.blank();
+      return;
+    }
+    logger.bold(`${summary.totalRepos} context repo(s) \u2014 ${summary.totalFiles} file(s), ${formatSize(summary.totalSize)}`);
+    logger.blank();
+    for (const repo of summary.repos) {
+      logger.info(`${repo.name}`);
+      logger.dim(`  Path: ${repo.path}`);
+      logger.dim(`  Files: ${repo.fileCount} (${formatSize(repo.totalSize)})`);
+      if (repo.typeBreakdown.length > 0) {
+        logger.dim(`  Types: ${repo.typeBreakdown.join(", ")}`);
+      }
+      logger.dim(`  Indexed: ${repo.indexedAt}`);
+      logger.blank();
+    }
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+contextCommand.command("reindex [path-or-name]").description("Re-scan files in one or all context directories").action(async (pathOrName) => {
+  try {
+    const interactive = isInteractive();
+    if (interactive) {
+      await withSpinner(
+        "Re-scanning documents...",
+        async () => reindexContext(pathOrName),
+        "Reindex complete"
+      );
+    } else {
+      logger.blank();
+      reindexContext(pathOrName);
+      logger.blank();
+    }
+  } catch (err) {
+    logger.error(err.message);
+    process.exit(1);
+  }
+});
+
 // src/index.ts
 init_prompts();
-var program = new Command16();
-program.name("planmode").description("The open source package manager for AI plans, rules, and prompts.").version("0.3.0");
+var program = new Command17();
+program.name("planmode").description("The open source package manager for AI plans, rules, and prompts.").version("0.4.0");
 program.addCommand(installCommand);
 program.addCommand(uninstallCommand);
 program.addCommand(searchCommand);
@@ -3262,6 +3662,7 @@ program.addCommand(doctorCommand);
 program.addCommand(testCommand);
 program.addCommand(recordCommand);
 program.addCommand(snapshotCommand);
+program.addCommand(contextCommand);
 if (process.argv.length <= 2 && isInteractive()) {
   const { runInteractiveMenu: runInteractiveMenu2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
   runInteractiveMenu2();