planmode 0.2.2 → 0.4.0

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`;
+}

package/src/lib/installer.ts

@@ -11,6 +11,7 @@ import { parseManifest, readPackageContent } from "./manifest.js";
 import { renderTemplate, collectVariableValues } from "./template.js";
 import { logger } from "./logger.js";
 import { trackDownload } from "./analytics.js";
+import { isInteractive, promptForVariables, withSpinner } from "./prompts.js";
 
 function getInstallDir(type: PackageType): string {
   switch (type) {
@@ -37,6 +38,7 @@ export interface InstallOptions {
   noInput?: boolean;
   variables?: Record<string, string>;
   projectDir?: string;
+  interactive?: boolean;
 }
 
 export async function installPackage(
@@ -44,6 +46,7 @@ export async function installPackage(
   options: InstallOptions = {},
 ): Promise<void> {
   const projectDir = options.projectDir ?? process.cwd();
+  const interactive = options.interactive ?? (isInteractive() && !options.noInput);
 
   // Check lockfile first
   const locked = getLockedVersion(packageName, projectDir);
@@ -53,44 +56,68 @@ export async function installPackage(
   }
 
   // Resolve version
-  logger.info(`Resolving ${packageName}...`);
-  const { version, metadata } = await resolveVersion(packageName, options.version);
-
-  // Fetch version metadata
-  const versionMeta = await fetchVersionMetadata(packageName, version);
-
-  // Fetch manifest
-  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);
-
-  // Fetch content
-  let content: string;
-  if (manifest.content) {
-    content = manifest.content;
-  } else if (manifest.content_file) {
-    content = await fetchFileAtTag(
+  const resolveAndFetch = async () => {
+    const { version, metadata } = await resolveVersion(packageName, options.version);
+    const versionMeta = await fetchVersionMetadata(packageName, version);
+    return { version, metadata, versionMeta };
+  };
+
+  const { version, metadata, versionMeta } = interactive
+    ? await withSpinner(
+        `Resolving ${packageName}...`,
+        resolveAndFetch,
+        `Resolved ${packageName}`,
+      )
+    : await (async () => {
+        logger.info(`Resolving ${packageName}...`);
+        return resolveAndFetch();
+      })();
+
+  // Fetch manifest and content
+  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 manifest = parseManifest(manifestRaw);
+
+    let content: string;
+    if (manifest.content) {
+      content = manifest.content;
+    } else if (manifest.content_file) {
+      content = await fetchFileAtTag(
+        versionMeta.source.repository,
+        versionMeta.source.tag,
+        `${basePath}${manifest.content_file}`,
+      );
+    } else {
+      throw new Error("Package has no content or content_file");
+    }
+
+    return { manifest, content };
+  };
+
+  const { manifest, content: rawContent } = interactive
+    ? await withSpinner(
+        `Fetching ${packageName}@${version}...`,
+        fetchContent,
+        `Fetched ${packageName}@${version}`,
+      )
+    : await (async () => {
+        logger.info(`Fetching ${packageName}@${version}...`);
+        return fetchContent();
+      })();
 
   // Process variables if templated
+  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 {
-      // Use defaults for non-provided values
       const values = collectVariableValues(manifest.variables, provided);
       content = renderTemplate(content, values);
     }
@@ -170,6 +197,7 @@ export async function installPackage(
         version: range === "*" ? undefined : range,
         projectDir,
         noInput: options.noInput,
+        interactive: options.interactive,
       });
     }
   }

package/src/lib/prompts.ts

@@ -0,0 +1,159 @@
+import * as p from "@clack/prompts";
+import type { VariableDefinition } from "../types/index.js";
+
+/**
+ * Returns true if the CLI is running in an interactive terminal.
+ * False when piped, in CI, or when --no-input is set.
+ */
+export function isInteractive(): boolean {
+  return Boolean(process.stdin.isTTY) && !process.env.CI;
+}
+
+/**
+ * Wraps a clack prompt result — if the user cancels (Ctrl+C),
+ * prints a cancel message and exits cleanly.
+ */
+export function handleCancel<T>(value: T | symbol): T {
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return value as T;
+}
+
+/**
+ * Prompts for a single manifest variable using the appropriate clack widget.
+ */
+async function promptForVariable(
+  name: string,
+  def: VariableDefinition,
+): Promise<string | number | boolean> {
+  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 !== undefined ? String(def.default) : undefined,
+      });
+      return handleCancel(value);
+    }
+
+    case "boolean": {
+      const value = await p.confirm({
+        message: def.description || name,
+        initialValue: def.default !== undefined ? Boolean(def.default) : false,
+      });
+      return handleCancel(value);
+    }
+
+    case "number": {
+      const value = await p.text({
+        message: def.description || name,
+        placeholder: def.default !== undefined ? String(def.default) : undefined,
+        defaultValue: def.default !== undefined ? String(def.default) : undefined,
+        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 !== undefined ? String(def.default) : undefined,
+        defaultValue: def.default !== undefined ? String(def.default) : undefined,
+        validate(input) {
+          if (def.required && !input) return `${name} is required`;
+        },
+      });
+      return handleCancel(value);
+    }
+  }
+}
+
+/**
+ * Collects all missing variable values interactively.
+ * Merges with already-provided values.
+ * Falls back to defaults or throws if not interactive.
+ */
+export async function promptForVariables(
+  variableDefs: Record<string, VariableDefinition>,
+  provided: Record<string, string>,
+  noInput: boolean = false,
+): Promise<Record<string, string | number | boolean>> {
+  const values: Record<string, string | number | boolean> = {};
+
+  for (const [name, def] of Object.entries(variableDefs)) {
+    if (def.type === "resolved") continue;
+
+    if (provided[name] !== undefined) {
+      values[name] = coerceValue(provided[name]!, def);
+    } else if (def.default !== undefined) {
+      if (isInteractive() && !noInput) {
+        // In interactive mode, let user confirm/change defaults
+        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 coerceValue(
+  raw: string,
+  def: VariableDefinition,
+): string | number | boolean {
+  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;
+  }
+}
+
+/**
+ * Wraps an async operation with a clack spinner.
+ * Only shows spinner when interactive.
+ */
+export async function withSpinner<T>(
+  message: string,
+  fn: () => Promise<T>,
+  successMessage?: string,
+): Promise<T> {
+  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;
+  }
+}