planmode 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "planmode",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "The open source package manager for AI plans, rules, and prompts.",
   "type": "module",
   "bin": {

package/src/commands/context.ts

@@ -0,0 +1,111 @@
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import { addContextRepo, removeContextRepo, reindexContext, getContextSummary, formatSize } from "../lib/context.js";
+import { logger } from "../lib/logger.js";
+import { isInteractive, withSpinner } from "../lib/prompts.js";
+
+export const contextCommand = new Command("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: string, options: { name?: string }) => {
+    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 as Error).message);
+      process.exit(1);
+    }
+  });
+
+contextCommand
+  .command("remove <path-or-name>")
+  .description("Remove a directory from the project context")
+  .action((pathOrName: string) => {
+    try {
+      logger.blank();
+      removeContextRepo(pathOrName);
+      logger.blank();
+    } catch (err) {
+      logger.error((err as Error).message);
+      process.exit(1);
+    }
+  });
+
+contextCommand
+  .command("list")
+  .description("Show all directories in the project context")
+  .option("--json", "Output as JSON")
+  .action((options: { json?: boolean }) => {
+    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) — ${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 as Error).message);
+      process.exit(1);
+    }
+  });
+
+contextCommand
+  .command("reindex [path-or-name]")
+  .description("Re-scan files in one or all context directories")
+  .action(async (pathOrName?: string) => {
+    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 as Error).message);
+      process.exit(1);
+    }
+  });

package/src/commands/interactive.ts

@@ -7,6 +7,7 @@ import { searchPackages, fetchPackageMetadata, fetchIndex } from "../lib/registr
 import { installPackage } from "../lib/installer.js";
 import { readLockfile } from "../lib/lockfile.js";
 import { runDoctor } from "../lib/doctor.js";
+import { addContextRepo, removeContextRepo, reindexContext, getContextSummary, formatSize, readContextIndex } from "../lib/context.js";
 import type { PackageSummary } from "../types/index.js";
 
 type Action =
@@ -15,6 +16,7 @@ type Action =
   | "install"
   | "create"
   | "list"
+  | "context"
   | "doctor"
   | "exit";
 
@@ -195,6 +197,7 @@ async function mainMenu(): Promise<void> {
           { value: "install" as Action, label: "Install a package", hint: "install by name" },
           { value: "create" as Action, label: "Create a new package" },
           { value: "list" as Action, label: "My installed packages" },
+          { value: "context" as Action, label: "Manage context", hint: "document directories for AI" },
           { value: "doctor" as Action, label: "Health check" },
           { value: "exit" as Action, label: "Exit" },
         ],
@@ -219,6 +222,9 @@ async function mainMenu(): Promise<void> {
       case "list":
         listFlow();
         break;
+      case "context":
+        await contextFlow();
+        break;
       case "doctor":
         doctorFlow();
         break;
@@ -407,6 +413,107 @@ async function installFlow(): Promise<void> {
   }
 }
 
+type ContextAction = "add" | "remove" | "reindex" | "back";
+
+async function contextFlow(): Promise<void> {
+  const summary = getContextSummary();
+
+  if (summary.totalRepos === 0) {
+    p.log.info("No context repos yet.");
+  } else {
+    const lines = summary.repos.map(
+      (r) => `${r.name} — ${r.fileCount} file(s), ${formatSize(r.totalSize)}`,
+    );
+    p.note(lines.join("\n"), `${summary.totalRepos} context repo(s)`);
+  }
+
+  const action = handleCancel(
+    await p.select<ContextAction>({
+      message: "What would you like to do?",
+      options: [
+        { value: "add" as ContextAction, label: "Add a directory" },
+        { value: "remove" as ContextAction, label: "Remove a directory" },
+        { value: "reindex" as ContextAction, label: "Re-index all" },
+        { value: "back" as ContextAction, label: "Back" },
+      ],
+    }),
+  );
+
+  if (action === "back") return;
+
+  if (action === "add") {
+    const dirPath = handleCancel(
+      await p.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 p.text({
+        message: "Label (optional):",
+        placeholder: "e.g. Project Documentation",
+      }),
+    );
+
+    try {
+      await withSpinner(
+        "Indexing documents...",
+        async () => addContextRepo(dirPath, { name: name || undefined }),
+        "Indexing complete",
+      );
+    } catch (err) {
+      p.log.error((err as Error).message);
+    }
+  } else if (action === "remove") {
+    if (summary.totalRepos === 0) {
+      p.log.warn("No context repos to remove.");
+      return;
+    }
+
+    const selected = handleCancel(
+      await p.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);
+      p.log.success(`Removed "${selected}"`);
+    } catch (err) {
+      p.log.error((err as Error).message);
+    }
+  } else if (action === "reindex") {
+    if (summary.totalRepos === 0) {
+      p.log.warn("No context repos to reindex.");
+      return;
+    }
+
+    try {
+      await withSpinner(
+        "Re-scanning documents...",
+        async () => reindexContext(),
+        "Reindex complete",
+      );
+    } catch (err) {
+      p.log.error((err as Error).message);
+    }
+  }
+}
+
 function listFlow(): void {
   const lockfile = readLockfile();
   const entries = Object.entries(lockfile.packages);

package/src/index.ts

@@ -14,6 +14,7 @@ import { doctorCommand } from "./commands/doctor.js";
 import { testCommand } from "./commands/test.js";
 import { recordCommand } from "./commands/record.js";
 import { snapshotCommand } from "./commands/snapshot.js";
+import { contextCommand } from "./commands/context.js";
 import { isInteractive } from "./lib/prompts.js";
 
 const program = new Command();
@@ -21,7 +22,7 @@ const program = new Command();
 program
   .name("planmode")
   .description("The open source package manager for AI plans, rules, and prompts.")
-  .version("0.3.0");
+  .version("0.4.0");
 
 program.addCommand(installCommand);
 program.addCommand(uninstallCommand);
@@ -38,6 +39,7 @@ program.addCommand(doctorCommand);
 program.addCommand(testCommand);
 program.addCommand(recordCommand);
 program.addCommand(snapshotCommand);
+program.addCommand(contextCommand);
 
 // If no args and interactive TTY, show the interactive menu
 if (process.argv.length <= 2 && isInteractive()) {

package/src/lib/context.ts

@@ -0,0 +1,265 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse, stringify } from "yaml";
+import type { ContextIndex, ContextRepoIndex, IndexedFile } from "../types/index.js";
+import { logger } from "./logger.js";
+
+const CONTEXT_DIR = ".planmode";
+const CONTEXT_FILE = "context.yaml";
+
+const SUPPORTED_EXTENSIONS = new Set([
+  ".txt", ".md", ".markdown", ".pdf", ".rtf",
+  ".doc", ".docx", ".csv", ".tsv", ".json",
+  ".yaml", ".yml", ".xml", ".html", ".htm",
+  ".rst", ".org", ".tex", ".log",
+]);
+
+const IGNORED_DIRS = new Set([
+  "node_modules", ".git", "dist", "build", ".next",
+  "__pycache__", ".venv", "venv", ".tox",
+  "target", "out", ".cache", ".turbo",
+  "coverage", ".nyc_output",
+]);
+
+function getContextPath(projectDir: string): string {
+  return path.join(projectDir, CONTEXT_DIR, CONTEXT_FILE);
+}
+
+function emptyIndex(): ContextIndex {
+  return { version: 1, repos: [] };
+}
+
+export function readContextIndex(projectDir: string = process.cwd()): ContextIndex {
+  const filePath = getContextPath(projectDir);
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const data = parse(raw) as ContextIndex;
+    return data ?? emptyIndex();
+  } catch {
+    return emptyIndex();
+  }
+}
+
+export function writeContextIndex(index: ContextIndex, projectDir: string = process.cwd()): void {
+  const dirPath = path.join(projectDir, CONTEXT_DIR);
+  fs.mkdirSync(dirPath, { recursive: true });
+  const filePath = getContextPath(projectDir);
+  fs.writeFileSync(filePath, stringify(index), "utf-8");
+}
+
+export function walkDirectory(dirPath: string): IndexedFile[] {
+  const files: IndexedFile[] = [];
+
+  function walk(currentPath: string): void {
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.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 = path.join(currentPath, entry.name);
+
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
+
+        try {
+          const stat = fs.statSync(fullPath);
+          const relativePath = path.relative(dirPath, fullPath);
+          files.push({
+            path: relativePath,
+            extension: ext,
+            size: stat.size,
+            modified_at: stat.mtime.toISOString(),
+          });
+        } catch {
+          // Skip files we can't stat
+        }
+      }
+    }
+  }
+
+  walk(dirPath);
+  return files;
+}
+
+export function addContextRepo(
+  repoPath: string,
+  options: { name?: string; projectDir?: string } = {},
+): ContextRepoIndex {
+  const projectDir = options.projectDir ?? process.cwd();
+  const absolutePath = path.resolve(projectDir, repoPath);
+
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Directory not found: ${repoPath}`);
+  }
+
+  if (!fs.statSync(absolutePath).isDirectory()) {
+    throw new Error(`Not a directory: ${repoPath}`);
+  }
+
+  const index = readContextIndex(projectDir);
+
+  // Store relative path if inside project, absolute otherwise
+  const relative = path.relative(projectDir, absolutePath);
+  const isInsideProject = !relative.startsWith("..") && !path.isAbsolute(relative);
+  const storedPath = isInsideProject ? relative : absolutePath;
+
+  // Check if already added
+  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 = new Date().toISOString();
+  const repoIndex: ContextRepoIndex = {
+    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}" — ${files.length} file(s), ${formatSize(repoIndex.total_size)}`);
+
+  // Log type breakdown
+  const breakdown = getTypeBreakdown(files);
+  if (breakdown.length > 0) {
+    logger.dim(`  ${breakdown.join(", ")}`);
+  }
+
+  return repoIndex;
+}
+
+export function removeContextRepo(
+  pathOrName: string,
+  projectDir: string = process.cwd(),
+): void {
+  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}"`);
+}
+
+export function reindexContext(
+  pathOrName?: string,
+  projectDir: string = process.cwd(),
+): void {
+  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 = path.resolve(projectDir, repo.repo.path);
+
+    if (!fs.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 = 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}" — ${files.length} file(s), ${formatSize(repo.total_size)}`);
+  }
+
+  writeContextIndex(index, projectDir);
+}
+
+export interface ContextSummary {
+  totalRepos: number;
+  totalFiles: number;
+  totalSize: number;
+  repos: Array<{
+    name: string;
+    path: string;
+    fileCount: number;
+    totalSize: number;
+    typeBreakdown: string[];
+    indexedAt: string;
+  }>;
+}
+
+export function getContextSummary(projectDir: string = process.cwd()): ContextSummary {
+  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: IndexedFile[]): string[] {
+  const counts = new Map<string, number>();
+  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}`);
+}
+
+export function formatSize(bytes: number): string {
+  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`;
+}