pi-supernova 0.0.11 → 0.1.0

package/render.js

@@ -12,124 +12,11 @@
 
 import { stripVTControlCharacters } from "node:util";
 import { isString, isObject, isFunction } from "./decode.js";
-import {
-	measureWidth,
-	hardTruncate,
-	clampLine,
-	wrapPlainToWidth,
-	fitPath,
-} from "./render-measure.js";
+import { measureWidth, hardTruncate, clampLine, fitPath, wrapLine } from "./render-measure.js";
 import { novaFramedBlock, novaStatusLine } from "./omp-frame.js";
 import { formatValue } from "./format.js";
 
-export { measureWidth, hardTruncate, clampLine, wrapPlainToWidth, fitPath };
-
-function fitOutputLines(text, width) {
-	const w = Math.max(1, width | 0);
-	const out = [];
-	for (const line of String(text ?? "")
-		.replace(/\t/g, "   ")
-		.split("\n")) {
-		if (measureWidth(line) <= w) {
-			out.push(line);
-			continue;
-		}
-		// Wrap on plain text so long paths continue on the next line instead of
-		// dying as `packages/pi-supern…`. ANSI is dropped on wrap (crash-safety).
-		const plain = stripVTControlCharacters(line);
-		for (const chunk of wrapPlainToWidth(plain, w)) {
-			out.push(clampLine(chunk, w));
-		}
-	}
-	return out.length > 0 ? out : [""];
-}
-
-/** Compact bounded text; the host supplies the card background and borders. */
-export class SafeText {
-	constructor(text = "") {
-		this.text = text;
-	}
-	setText(text) {
-		this.text = text;
-	}
-	invalidate() {}
-	render(width = 80) {
-		const raw = String(this.text ?? "");
-		return raw.trim() ? fitOutputLines(raw, Math.max(1, width | 0)) : [];
-	}
-}
-
-// Keep names some tests / older call sites may import.
-export const visibleWidth = measureWidth;
-export const truncateToWidth = hardTruncate;
-
-export function extractOperationsFromCode(code) {
-	const trimmed = String(code || "").trim();
-	if (!trimmed) return [];
-
-	const ops = [];
-	const seen = new Set();
-
-	const addOp = (tool, target) => {
-		const key = `${tool}:${target}`;
-		if (!seen.has(key)) {
-			seen.add(key);
-			ops.push({ tool, target });
-		}
-	};
-
-	const callRegex = /nova\.call\s*\(\s*["'`]([a-zA-Z0-9_-]+)["'`](?:\s*,\s*(\{[\s\S]*?\}))?/g;
-	let match;
-	while ((match = callRegex.exec(trimmed)) !== null) {
-		const tool = match[1];
-		let target = "";
-		if (match[2]) {
-			const pathMatch = /path\s*:\s*["'`]([^"'`]+)["'`]/.exec(match[2]);
-			const cmdMatch = /command\s*:\s*["'`]([^"'`]+)["'`]/.exec(match[2]);
-			const patMatch = /pattern\s*:\s*["'`]([^"'`]+)["'`]/.exec(match[2]);
-			if (pathMatch) target = pathMatch[1];
-			else if (cmdMatch) target = cmdMatch[1].length > 30 ? cmdMatch[1].slice(0, 27) + "…" : cmdMatch[1];
-			else if (patMatch) target = patMatch[1];
-		}
-		addOp(tool, target);
-	}
-
-	const callManyRegex = /nova\.callMany\s*\(\s*\[([\s\S]*?)\]\s*\)/g;
-	while ((match = callManyRegex.exec(trimmed)) !== null) {
-		const inner = match[1];
-		const subCalls = inner.matchAll(/name\s*:\s*["'`]([a-zA-Z0-9_-]+)["'`]/g);
-		for (const sub of subCalls) addOp(sub[1], "");
-	}
-
-	const namedCalls = [
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?read\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "read", wrap: (p) => p },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?write\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "write", wrap: (p) => p },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?edit\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "edit", wrap: (p) => p },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?patch\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "patch", wrap: (p) => p },
-		{
-			regex: /(?:^|[^\w$.])(?:nova\.)?bash\s*\(\s*["'`]([^"'`]+)["'`]/gm,
-			tool: "bash",
-			wrap: (c) => (c.length > 32 ? c.slice(0, 29) + "…" : c),
-		},
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?exec\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "exec", wrap: (c) => c },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?search\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "search", wrap: (q) => `"${q}"` },
-		{ regex: /(?:^|[^\w$.])nova\.describe\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "describe", wrap: (name) => name },
-		{ regex: /(?:^|[^\w$.])nova\.has\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "has", wrap: (name) => name },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?surface\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "surface", wrap: (p) => p },
-		{ regex: /(?:^|[^\w$.])(?:nova\.)?snap\s*\(\s*["'`]([^"'`]+)["'`]/gm, tool: "snap", wrap: (q) => `"${q}"` },
-	];
-	for (const item of namedCalls) {
-		while ((match = item.regex.exec(trimmed)) !== null) {
-			addOp(item.tool, item.wrap(match[1]));
-		}
-	}
-
-	if (/nova\.speculate\s*\(/.test(trimmed)) {
-		addOp("speculate", "(branch foam)");
-	}
-
-	return ops;
-}
+export { measureWidth, hardTruncate, clampLine };
 
 function formatDiffRows(diff, theme, maxShown = 6) {
 	if (!diff || !Array.isArray(diff.lines) || diff.lines.length === 0) return [];
@@ -217,7 +104,7 @@ export function normalizeCallRenderArgs(a, b, c) {
 /**
  * Dual-host renderResult args:
  *   Pi:  (result, {expanded,isPartial}, theme, context)
- *   OMP: (result, {expanded,isPartial}, theme, args)  — 4th is args, not context
+ *   OMP: (result, {expanded,isPartial}, theme, args)  (4th is args, not context)
  *
  * Call shapes share the first three positions, so host is inferred from the
  * fourth argument's context-versus-args shape.
@@ -237,7 +124,7 @@ function detectResultHost(options, ctxOrArgs) {
 	return "pi";
 }
 
-export function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs) {
+function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs) {
 	if (isTheme(themeOrCtx)) {
 		const opts = isObject(options) ? options : {};
 		const context = contextFrom(opts, ctxOrArgs);
@@ -333,20 +220,20 @@ function operationsFromTrace(trace) {
 		.filter(Boolean);
 }
 
+// The call slot is always empty: the result card owns the whole lifecycle in both hosts.
+const EMPTY_CALL = { render: () => [], invalidate() {} };
+
 export function renderSupernovaCall(a, b, c) {
 	const { context, options } = normalizeCallRenderArgs(a, b, c);
-	const comp = context?.lastComponent instanceof SafeText ? context.lastComponent : new SafeText();
-	if (options) options.lastComponent = comp;
-	else if (context) context.lastComponent = comp;
-	comp.setText("");
-	return comp;
+	if (options) options.lastComponent = EMPTY_CALL;
+	else if (context) context.lastComponent = EMPTY_CALL;
+	return EMPTY_CALL;
 }
 
 const TOOL_COL = 7;
 const DURATION_COL = 6;
-const PREVIEW_LINES = 24;
 
-export function formatDuration(ms) {
+function formatDuration(ms) {
 	if (!Number.isFinite(ms) || ms < 0) return "";
 	if (ms < 1000) return `${Math.round(ms)}ms`;
 	if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
@@ -418,19 +305,13 @@ function formatOpRow(theme, op, width, isPartial, isError) {
 	return prefix.trimEnd();
 }
 
-function operationsFor(payload, context, args) {
-	const trace = payload?.trace || context?.state?.trace || [];
-	const traced = operationsFromTrace(trace);
-	if (traced.length > 0) return traced;
-	return extractOperationsFromCode(args?.code).map((op) => displayOperation(op.tool, op.target)).filter(Boolean);
+function operationsFor(payload, context) {
+	return operationsFromTrace(payload?.trace || context?.state?.trace || []);
 }
 
-function resultLines(value, maxLines) {
+function resultLines(value, width) {
 	const text = isString(value) ? value : formatValue(value);
-	const lines = cleanBlockText(text).split("\n");
-	const shown = lines.slice(0, maxLines);
-	if (lines.length > maxLines) shown.push(`… ${lines.length - maxLines} more lines`);
-	return shown;
+	return cleanBlockText(text).split("\n").flatMap(line => wrapLine(line, width));
 }
 
 function appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError) {
@@ -442,15 +323,18 @@ function appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, is
 	if (ops.length > maxOps) lines.push(theme.fg("dim", `  … ${ops.length - maxOps} more calls`));
 }
 
-function appendTail(lines, theme, payload, expanded, isError) {
-	if (isError) lines.push(theme.fg("error", "✗ " + (payload?.error ? cleanBlockText(payload.error) : "error")));
+function appendTail(lines, theme, payload, expanded, isError, width) {
+	if (isError) {
+		const error = "✗ " + (payload?.error ? cleanBlockText(payload.error) : "error");
+		for (const line of expanded ? resultLines(error, width) : error.split("\n")) lines.push(theme.fg("error", line));
+	}
 	else if (expanded && payload?.result !== undefined) {
 		lines.push(theme.fg("dim", "── result ──"));
-		for (const line of resultLines(payload.result, PREVIEW_LINES)) lines.push(theme.fg("toolOutput", line));
+		for (const line of resultLines(payload.result, width)) lines.push(theme.fg("toolOutput", line));
 	}
 	if (expanded && payload?.logs?.length) {
 		lines.push(theme.fg("dim", "── logs ──"));
-		for (const log of payload.logs.slice(0, PREVIEW_LINES)) lines.push(theme.fg("dim", cleanBlockText(log)));
+		for (const log of payload.logs) for (const line of resultLines(log, width)) lines.push(theme.fg("dim", line));
 	}
 }
 
@@ -460,7 +344,7 @@ function buildBodyLines(theme, width, { payload, context, args, expanded, isPart
 	const maxDiffLines = expanded ? 24 : 8;
 	const lines = [];
 	appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError);
-	appendTail(lines, theme, payload, expanded, isError);
+	appendTail(lines, theme, payload, expanded, isError, width);
 	return { lines, opCount: ops.length };
 }
 
@@ -475,33 +359,34 @@ class UnifiedResultCard {
 	set(theme, model) {
 		this.theme = theme;
 		this.model = model;
-		this.frame = undefined;
+		this.cache = undefined;
 	}
 	invalidate() {
-		this.frame = undefined;
+		this.cache = undefined;
 	}
 	render(width = 80) {
 		const { theme, model } = this;
-		if (!theme || !model) return [];
-		if (!this.frame) {
-			this.frame = novaFramedBlock(theme, (frameWidth) => {
-				const contentWidth = Math.max(1, frameWidth - 4);
-				const view = buildBodyLines(theme, contentWidth, model);
-				return {
-					header: novaStatusLine(theme, {
-						icon: model.isError ? "error" : model.isPartial ? "running" : undefined,
-						title: "nova",
-						description: describeCard(model, view.opCount),
-					}),
-					sections: view.lines.length > 0 ? [{ lines: view.lines }] : [],
+		if (!theme || !model || width <= 0) return [];
+		if (this.cache?.width === width) return this.cache.lines;
+		const view = buildBodyLines(theme, Math.max(1, width - 4), model);
+		const header = novaStatusLine(theme, {
+			icon: model.isError ? "error" : model.isPartial ? "running" : undefined,
+			title: "nova",
+			description: describeCard(model, view.opCount),
+		});
+		// A program with no host calls has nothing to frame: one status line, no empty box.
+		const lines = view.lines.length === 0
+			? [clampLine(header, width)]
+			: novaFramedBlock(theme, () => ({
+					header,
+					sections: [{ lines: view.lines }],
 					state: model.isError ? "error" : model.isPartial ? "pending" : "success",
 					// borderMuted is invisible on OMP's card background; dim matches the duration column.
 					borderColor: model.isError ? "error" : "dim",
-					width: frameWidth,
-				};
-			});
-		}
-		return this.frame.render(width);
+					width,
+				})).render(width);
+		this.cache = { width, lines };
+		return lines;
 	}
 }
 

package/repo-index.js

@@ -1,13 +1,19 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { extractStructuralSurface } from "./surface.js";
+import { isFunction } from "./decode.js";
+import { Frecency } from "./fuzzy.js";
+import { relativeSlash } from "./workspace.js";
 
 // In-process workspace index: the gitignore-aware file list comes from one
 // \`rg --files\` spawn and is then reused; file text, lowercase text, and the
 // structural surface are cached per path and validated by mtime. snap/grep/glob
 // read from here instead of spawning, so a warm call is sub-millisecond.
 
+// With a working fs.watch the list only refreshes on change; the TTL is the fallback when watching fails.
 const LIST_TTL_MS = 10_000;
+const WATCHED_TTL_MS = 5 * 60_000;
+const WATCH_DEBOUNCE_MS = 150;
 const MAX_INDEXED_FILES = 4000;
 const MAX_FILE_BYTES = 512 * 1024;
 const BINARY_EXT = new Set([
@@ -20,7 +26,12 @@ const IDENT_TOKEN = /[A-Za-z_$][\w$]*/g;
 const EMPTY = Object.freeze([]);
 const DEF_PATTERN = /^(?:pub\s+)?(?:export\s+)?(?:async\s+)?(?:default\s+)?(function|class|def|fn|const|let|interface|type|struct|enum)\s+([a-zA-Z0-9_$]+)/;
 
-export function isTextCandidate(filePath) {
+/** Declared identifier on a line (function/class/const/…), or ""; the same rule snap and grep use. */
+export function declaredName(line) {
+  return DEF_PATTERN.exec(String(line).trim())?.[2] ?? "";
+}
+
+function isTextCandidate(filePath) {
   return !BINARY_EXT.has(path.extname(filePath).toLowerCase());
 }
 
@@ -69,17 +80,81 @@ export class WorkspaceIndex {
     this.runCommand = runCommand;
     this.lists = new Map();
     this.entries = new Map();
+    this.watchers = new Map();
+    this.frecency = new Frecency();
+    this.gitModified = new Map(); // root → Set(relative "/"-joined paths)
+    this.lastTouched = null;
   }
 
   invalidate() {
     this.lists.clear();
   }
 
+  /** fff frecency: every read/edit is an access; the newest one is the "current file" for distance penalties. */
+  touch(relPath) {
+    this.frecency.record(relPath);
+    this.lastTouched = relPath;
+  }
+
+  watch(root) {
+    if (this.watchers.has(root)) return this.watchers.get(root);
+    let ok = false;
+    try {
+      let timer = null;
+      const watcher = fs.watch(root, { recursive: true }, () => {
+        if (timer) return;
+        timer = setTimeout(() => {
+          timer = null;
+          this.lists.clear();
+          this.gitModified.delete(root);
+        }, WATCH_DEBOUNCE_MS);
+      });
+      watcher.on("error", () => {
+        this.watchers.set(root, false);
+        this.lists.clear();
+      });
+      if (isFunction(watcher.unref)) watcher.unref();
+      ok = true;
+    } catch {
+      ok = false;
+    }
+    this.watchers.set(root, ok);
+    return ok;
+  }
+
+  /** Paths git reports as modified/added/untracked (fff's git-status boost); one spawn per list refresh. */
+  async modifiedFiles(root) {
+    const cached = this.gitModified.get(root);
+    if (cached) return cached;
+    const set = new Set();
+    try {
+      const res = await this.runCommand(["git", "status", "--porcelain", "-z", "--untracked-files=all"], { cwd: root, timeoutMs: 5_000 });
+      if (res.exitCode === 0) {
+        for (const row of res.stdout.split("\0")) {
+          if (row.length > 3) set.add(row.slice(3));
+        }
+      }
+    } catch {}
+    this.gitModified.set(root, set);
+    return set;
+  }
+
+  mtimeSeconds(filePath) {
+    const e = this.entries.get(filePath);
+    if (e) return e.mtimeMs / 1000;
+    try {
+      return fs.statSync(filePath).mtimeMs / 1000;
+    } catch {
+      return 0;
+    }
+  }
+
   /** Absolute, sorted file list for a root; gitignore-aware via rg; cached for LIST_TTL_MS. */
   async files(root, includeHidden = false) {
     const key = root + "\0" + (includeHidden ? "h" : "");
     const cached = this.lists.get(key);
-    if (cached && Date.now() - cached.at < LIST_TTL_MS) return cached.files;
+    const ttl = this.watch(root) ? WATCHED_TTL_MS : LIST_TTL_MS;
+    if (cached && Date.now() - cached.at < ttl) return cached.files;
     const args = ["rg", "--files"];
     if (includeHidden) args.push("--hidden");
     args.push("-g", "!.git/**", "-g", "!**/.git/**", root);
@@ -114,16 +189,16 @@ export class WorkspaceIndex {
       return null;
     }
     if (text.includes("\0")) return null;
-    const created = { text, lower: text.toLowerCase(), mtimeMs: stat.mtimeMs, size: stat.size, ext: path.extname(filePath), surface: undefined, lines: undefined };
+    const created = { text, lower: text.toLowerCase(), mtimeMs: stat.mtimeMs, size: stat.size, ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
     this.entries.set(filePath, created);
     return created;
   }
 
   static fromText(filePath, text) {
-    return { text, lower: text.toLowerCase(), ext: path.extname(filePath), surface: undefined, lines: undefined };
+    return { text, lower: text.toLowerCase(), ext: path.extname(filePath), surface: undefined, lines: undefined, spans: undefined };
   }
 
-  /** Per-line raw text, lowercase text, declared identifier (or ""), and identifier tokens — computed once per entry. */
+  /** Per-line raw text, lowercase text, declared identifier (or ""), and identifier tokens, computed once per entry. */
   static linesOf(entry) {
     if (entry.lines) return entry.lines;
     const raw = entry.text.split("\n");
@@ -140,6 +215,25 @@ export class WorkspaceIndex {
     return entry.lines;
   }
 
+  /**
+   * Declaration spans [start, end] (1-based, inclusive) in file order, trailing blank lines trimmed.
+   * A span runs to the line before the next declaration; the file's leading header is not a span.
+   */
+  static spansOf(entry) {
+    if (entry.spans) return entry.spans;
+    const { items, lineCount } = WorkspaceIndex.surfaceOf(entry);
+    const { lower } = WorkspaceIndex.linesOf(entry);
+    const spans = [];
+    for (let i = 0; i < items.length; i++) {
+      const start = items[i].line;
+      let end = Math.min(i + 1 < items.length ? items[i + 1].line - 1 : lineCount, lineCount);
+      while (end > start && lower[end - 1] === "") end--;
+      spans.push({ start, end, name: items[i].name, kind: items[i].kind, isExport: items[i].isExport === true });
+    }
+    entry.spans = spans;
+    return spans;
+  }
+
   static surfaceOf(entry) {
     if (!entry.surface) entry.surface = extractStructuralSurface(entry.text, entry.ext);
     return entry.surface;
@@ -162,16 +256,17 @@ export class WorkspaceIndex {
     return hits;
   }
 
-  /** rg-style "path:line:text" rows over the indexed files, paths relative to root. */
-  grep(files, regex, root) {
+  /** Structured grep rows {rel, line, text, def}; def marks lines whose declared name itself matches. */
+  grepRows(files, regex, root) {
     const out = [];
+    const nameRegex = new RegExp(regex.source, "i");
     for (const filePath of files) {
       const e = this.entry(filePath);
       if (!e || !regex.test(e.text)) continue;
-      const lines = e.text.split("\n");
-      const rel = path.relative(root, filePath) || filePath;
-      for (let i = 0; i < lines.length; i++) {
-        if (regex.test(lines[i])) out.push(rel + ":" + (i + 1) + ":" + lines[i]);
+      const { raw, defNames } = WorkspaceIndex.linesOf(e);
+      const rel = relativeSlash(root, filePath);
+      for (let i = 0; i < raw.length; i++) {
+        if (regex.test(raw[i])) out.push({ rel, line: i + 1, text: raw[i], def: defNames[i] !== "" && nameRegex.test(defNames[i]) });
       }
     }
     return out;