copperhead 0.6.0 → 0.8.0

package/src/util/select.ts

@@ -0,0 +1,192 @@
+/**
+ * Minimal arrow-key select menu for TTY prompts (no extra deps).
+ * Renders an in-place "dropdown" navigable with ↑/↓ + Enter.
+ */
+
+import { copper, dim } from '../agent/theme.js';
+
+export interface SelectItem {
+  value: string;
+  label: string;
+  description?: string;
+}
+
+export interface SelectOptions {
+  title?: string;
+  items: SelectItem[];
+  input?: NodeJS.ReadStream;
+  output?: NodeJS.WriteStream;
+  /** Injected key stream for tests. */
+  keys?: AsyncIterable<string>;
+}
+
+const HIDE = '\x1b[?25l';
+const SHOW = '\x1b[?25h';
+const CLEAR_LINE = '\r\x1b[2K';
+
+function menuLines(title: string, items: SelectItem[], index: number): string[] {
+  const width = Math.max(...items.map((i) => i.label.length), 8);
+  return [
+    copper(`  ${title}`),
+    dim('  ↑/↓ move · Enter select · Esc cancel'),
+    '',
+    ...items.map((item, i) => {
+      const cursor = i === index ? copper('❯') : ' ';
+      const label = i === index ? copper(item.label.padEnd(width)) : dim(item.label.padEnd(width));
+      const desc = item.description ? dim(`  ${item.description}`) : '';
+      return `  ${cursor} ${label}${desc}`;
+    }),
+    '',
+  ];
+}
+
+async function* stdinKeys(input: NodeJS.ReadStream): AsyncGenerator<string> {
+  // Listener-based on purpose: `for await` over a Readable destroys the
+  // stream when the consumer breaks out, which would kill stdin for
+  // whatever runs after the menu (e.g. the REPL's KeyReader).
+  const wasRaw = input.isRaw;
+  if (typeof input.setRawMode === 'function') input.setRawMode(true);
+  input.resume();
+  input.setEncoding('utf8');
+
+  const queue: string[] = [];
+  let ended = false;
+  let notify: (() => void) | null = null;
+  const onData = (c: string | Buffer): void => {
+    queue.push(String(c));
+    notify?.();
+  };
+  const onEnd = (): void => {
+    ended = true;
+    notify?.();
+  };
+  input.on('data', onData);
+  input.on('end', onEnd);
+
+  try {
+    for (;;) {
+      while (queue.length) {
+        const s = queue.shift()!;
+        let i = 0;
+        while (i < s.length) {
+          if (s[i] === '\x1b' && s[i + 1] === '[') {
+            yield s.slice(i, i + 3);
+            i += 3;
+            continue;
+          }
+          // Lone Esc
+          if (s[i] === '\x1b') {
+            yield '\x1b';
+            i += 1;
+            continue;
+          }
+          yield s[i]!;
+          i += 1;
+        }
+      }
+      if (ended) return;
+      await new Promise<void>((resolve) => {
+        notify = resolve;
+      });
+      notify = null;
+    }
+  } finally {
+    input.off('data', onData);
+    input.off('end', onEnd);
+    input.pause();
+    if (typeof input.setRawMode === 'function') input.setRawMode(wasRaw ?? false);
+  }
+}
+
+/** Model choices offered when no model is configured anywhere. */
+export const MODEL_CHOICES: SelectItem[] = [
+  { value: 'claude-code', label: 'claude-code', description: 'Claude Code CLI (saved login)' },
+  { value: 'codex', label: 'codex', description: 'Codex CLI (saved login)' },
+  { value: 'cursor', label: 'cursor', description: 'Cursor CLI (saved login)' },
+  { value: 'claude', label: 'claude', description: 'Anthropic API (needs ANTHROPIC_API_KEY)' },
+  { value: 'gpt-5', label: 'gpt-5', description: 'OpenAI API (needs OPENAI_API_KEY)' },
+];
+
+/**
+ * Interactive model picker for a TTY session with no configured model.
+ * Resolves to the chosen model id, or null if cancelled.
+ */
+export async function pickModel(opts: Omit<SelectOptions, 'title' | 'items'> = {}): Promise<string | null> {
+  return selectMenu({ title: 'Select a model for this session', items: MODEL_CHOICES, ...opts });
+}
+
+/**
+ * Show a selectable list. Resolves to the chosen value, or null if cancelled.
+ */
+export async function selectMenu(opts: SelectOptions): Promise<string | null> {
+  const items = opts.items;
+  if (!items.length) return null;
+
+  const input = opts.input ?? process.stdin;
+  const output = opts.output ?? process.stdout;
+  const title = opts.title ?? 'Select';
+  let index = 0;
+  let lineCount = 0;
+
+  const paint = (): void => {
+    const lines = menuLines(title, items, index);
+    if (lineCount > 0) {
+      // Move to the first line of the previous paint and rewrite in place.
+      output.write(`\x1b[${lineCount}A`);
+    }
+    output.write(HIDE);
+    for (const line of lines) {
+      output.write(CLEAR_LINE + line + '\n');
+    }
+    lineCount = lines.length;
+  };
+
+  const erase = (): void => {
+    if (lineCount <= 0) {
+      output.write(SHOW);
+      return;
+    }
+    output.write(`\x1b[${lineCount}A`);
+    for (let i = 0; i < lineCount; i++) output.write(CLEAR_LINE + (i < lineCount - 1 ? '\n' : ''));
+    if (lineCount > 1) output.write(`\x1b[${lineCount - 1}A`);
+    output.write('\r' + SHOW);
+    lineCount = 0;
+  };
+
+  paint();
+
+  const keys = opts.keys ?? stdinKeys(input);
+  try {
+    for await (const key of keys) {
+      if (key === '\x03' || key === '\x1b') {
+        erase();
+        return null;
+      }
+      if (key === '\r' || key === '\n') {
+        const chosen = items[index]!.value;
+        erase();
+        return chosen;
+      }
+      if (key === '\x1b[A' || key === 'k') {
+        index = (index - 1 + items.length) % items.length;
+        paint();
+        continue;
+      }
+      if (key === '\x1b[B' || key === 'j') {
+        index = (index + 1) % items.length;
+        paint();
+        continue;
+      }
+      if (key >= '1' && key <= '9') {
+        const n = Number(key) - 1;
+        if (n >= 0 && n < items.length) {
+          index = n;
+          paint();
+        }
+      }
+    }
+  } finally {
+    erase();
+  }
+  return null;
+}

package/src/util/tmp.ts

@@ -0,0 +1,113 @@
+import { readdir, stat, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+/** Newest local-history entries to keep when capping `.history/` (see
+ *  pruneHistoryDir). Enough to preserve a useful recovery window, bounded enough
+ *  that the dir cannot grow without limit across a long run. */
+export const DEFAULT_HISTORY_KEEP = 200;
+
+/**
+ * Cap the growth of a repo's `.history/` directory (4.1). KiCad (and editor
+ * local-history) rewrite a snapshot on every project touch, so across a long
+ * run `.history/` grows without bound and was a contributor to the disk-fill
+ * halt (I8). It is gitignored, so its contents are disposable: keep the newest
+ * `keepNewest` files by mtime and remove the rest. Recursive (local history
+ * mirrors the workspace tree), best-effort (every error is swallowed — pruning
+ * housekeeping must never fail a run), and a no-op when the dir is absent or
+ * already under the cap. Returns the number of files removed.
+ */
+export async function pruneHistoryDir(repoRoot: string, keepNewest = DEFAULT_HISTORY_KEEP): Promise<number> {
+  const root = path.join(repoRoot, '.history');
+  const files: Array<{ full: string; mtimeMs: number }> = [];
+  const walk = async (dir: string): Promise<void> => {
+    let entries: Array<{ name: string; isDirectory(): boolean; isFile(): boolean }>;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return; // unreadable dir — skip it
+    }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        await walk(full);
+      } else if (e.isFile()) {
+        try {
+          const st = await stat(full);
+          files.push({ full, mtimeMs: st.mtimeMs });
+        } catch {
+          // stat race — skip this file
+        }
+      }
+    }
+  };
+  await walk(root);
+  if (files.length <= keepNewest) return 0;
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs); // newest first
+  let removed = 0;
+  for (const f of files.slice(keepNewest)) {
+    try {
+      await rm(f.full, { force: true });
+      removed++;
+    } catch {
+      // permission/race — leave it, keep pruning the rest
+    }
+  }
+  return removed;
+}
+
+/**
+ * Every scratch dir copperhead makes under the OS temp dir shares this prefix:
+ * kicad-cli ERC/DRC (`copperhead-`), the KiCad edit probe (`copperhead-validate-`),
+ * the failed-run backup (`copperhead-runs-`), and the provider working dirs
+ * (`copperhead-cc-`, `copperhead-codex-`). Each site removes its own dir in a
+ * `finally`, but a watchdog SIGKILL of the process tree or a hard abort skips
+ * that cleanup, so stale dirs accumulate across runs and can eventually fill the
+ * disk (I8). A prefix match lets one sweep reclaim all of them.
+ */
+export const TEMP_PREFIX = 'copperhead-';
+
+/** Default staleness cutoff for the startup sweep: 2h. Safe even for multi-hour
+ * runs (10-min turns × per-stage retries × 8 stages): a live run's only
+ * long-lived scratch dir is the provider's reused cwd, which is `utimes`-touched
+ * every turn (ClaudeCodeProvider.ensureCwd), so its mtime never goes stale while
+ * the process is alive; per-call kicad-cli dirs are removed within a turn. A dir
+ * older than this therefore belongs to a dead run, and the window is short enough
+ * that such a leak is reclaimed on the very next invocation. */
+export const DEFAULT_STALE_MS = 2 * 60 * 60 * 1000;
+
+/**
+ * Remove leaked `copperhead-*` scratch dirs left in the OS temp dir by earlier
+ * runs whose `finally` cleanup was skipped (watchdog kill / hard abort). Only
+ * dirs whose mtime is older than `maxAgeMs` are removed, so a concurrent run's
+ * fresh scratch dirs are never touched. Best-effort: every error is swallowed
+ * (a temp dir we can't stat or remove is not worth failing a run over), and the
+ * function returns the paths it removed so a caller can log the reclaim.
+ *
+ * `now` is injected so the behaviour is deterministically testable; callers pass
+ * `Date.now()`.
+ */
+export async function sweepStaleTempDirs(now: number, maxAgeMs = DEFAULT_STALE_MS): Promise<string[]> {
+  const root = tmpdir();
+  const removed: string[] = [];
+  let entries: string[];
+  try {
+    entries = await readdir(root);
+  } catch {
+    return removed; // no temp dir / not readable — nothing to sweep
+  }
+  for (const name of entries) {
+    if (!name.startsWith(TEMP_PREFIX)) continue;
+    const full = path.join(root, name);
+    try {
+      const st = await stat(full);
+      if (!st.isDirectory()) continue;
+      if (now - st.mtimeMs < maxAgeMs) continue; // too fresh: could be a live run
+      await rm(full, { recursive: true, force: true });
+      removed.push(full);
+    } catch {
+      // stat/rm race or permission issue — skip this entry, keep sweeping.
+    }
+  }
+  return removed;
+}