pi-supernova 0.1.0 → 0.3.0

package/{runtime.js → src/runtime/runtime.js}

@@ -1,8 +1,9 @@
 import { Worker } from "node:worker_threads";
 import { parse } from "acorn";
 import { performance } from "node:perf_hooks";
-import { packageFinalReturn } from "./bottleneck.js";
-import { isFunction, isObject, isString } from "./decode.js";
+import { packageFinalReturn } from "../output/bottleneck.js";
+import { truncateChars } from "../output/format.js";
+import { isFunction, isObject, isString } from "../shared/decode.js";
 
 const WORKER_URL = new URL("./guest-worker.js", import.meta.url);
 const ABORT_MESSAGE = "supernova timed out or aborted: pass timeoutMs to allow longer runs, or split the program";
@@ -52,7 +53,10 @@ function prepareProgram(code) {
 
 function spawnWorker(config) {
   const maxHeapMb = config.maxHeapMb ?? 512;
-  const worker = new Worker(WORKER_URL, { resourceLimits: { maxOldGenerationSizeMb: maxHeapMb } });
+  // An inline bootstrap accepts inherited --input-type from stdin/eval SDK hosts.
+  // Keep Node's automatic flag inheritance: explicitly copying execArgv can
+  // reintroduce process-only V8 flags that Worker rejects under node --test.
+  const worker = new Worker("import(" + JSON.stringify(WORKER_URL.href) + ")", { eval: true, resourceLimits: { maxOldGenerationSizeMb: maxHeapMb } });
   const handle = { worker, maxHeapMb, dead: false, ready: null };
   // This listener also owns errors between readiness and a run's listeners.
   worker.on("error", () => { handle.dead = true; });
@@ -111,6 +115,10 @@ export function warmGuestWorker(config = {}) {
   return handle.ready;
 }
 
+export function stopWarmGuestWorker() {
+  return killWorker(idleWorker);
+}
+
 const RPC_METHODS = {
   call: (nova, args) => nova.call(args[0], args[1]),
   callMany: async (nova, args) => {
@@ -128,7 +136,7 @@ export async function runGuestProgram({ code, nova = {}, config = {}, signal, on
   const started = performance.now();
   const wall = () => Math.round(performance.now() - started);
   const logs = [];
-  const fail = (error) => ({ ok: false, error, logs, logTruncated, wallMs: wall() });
+  const fail = (error) => ({ ok: false, error: truncateChars(String(error), config.maxReturnChars ?? 32000, "error").text, logs, logTruncated, wallMs: wall() });
   let logTruncated = false;
   if (!isString(code) || !code.trim()) return fail("code must be a non-empty string");
   if (code.length > (config.maxCodeChars ?? 48000)) return fail("code exceeds " + (config.maxCodeChars ?? 48000) + " characters");
@@ -234,7 +242,7 @@ export async function runGuestProgram({ code, nova = {}, config = {}, signal, on
         try {
           const packed = packageFinalReturn(msg.value, logs, config);
           void complete({ ok: true, result: packed.returnValue, resultText: packed.returnText,
-            returnTruncated: packed.returnTruncated, undefinedReturn: msg.undefinedReturn === true,
+            returnTruncated: packed.returnTruncated, images: packed.images, undefinedReturn: msg.undefinedReturn === true,
             logs: packed.logs, logTruncated: logTruncated || packed.logTruncated });
         } catch (err) {
           void complete(fail(err.message));
@@ -260,6 +268,7 @@ export async function runGuestProgram({ code, nova = {}, config = {}, signal, on
         if (wall() >= timeoutMs) return abort();
         handle.worker.postMessage({ op: "run", runId, prepared, available,
           batchRead: nova.batchRead !== false,
+          nativeArgv: nova.nativeArgv === true,
           limits: { maxLogLines: config.maxLogLines ?? 100, maxLogLineChars: config.maxLogLineChars ?? 4096 } });
       } catch (err) {
         cancelHost();

package/{omp-frame.js → src/ui/omp-frame.js}

@@ -6,7 +6,7 @@
  */
 
 import { clampLine, measureWidth } from "./render-measure.js";
-import { isFunction, isString } from "./decode.js";
+import { isFunction, isString } from "../shared/decode.js";
 
 const DEFAULT_BOX = {
 	topLeft: "╭",

package/{render-measure.js → src/ui/render-measure.js}

@@ -4,8 +4,34 @@ import stringWidth from "string-width";
 const ELLIPSIS = "…";
 const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 
+const widthCache = new Map();
+let cachedWidthChars = 0;
+const MAX_WIDTH_CACHE_CHARS = 512_000;
+
 export function measureWidth(text) {
-  return stringWidth(String(text ?? "").replace(/\t/g, "   "));
+  const raw = String(text ?? "");
+  const cached = widthCache.get(raw);
+  if (cached !== undefined) return cached;
+  const normalized = raw.replace(/\t/g, "   ");
+  // eslint-disable-next-line no-control-regex -- intentional ANSI SGR recognition
+  const plain = normalized.replace(/\x1b\[(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?m/g, "");
+  // ASCII and these single-column chrome glyphs need no Unicode segmentation.
+  // Any other character/control/escape sequence uses the full oracle.
+  const width = /^[\x20-\x7e\u2500-\u257f\u00b7\u00d7\u2026\u2713\u2717]*$/.test(plain)
+    ? plain.length
+    : stringWidth(normalized);
+  // Cache immutable text only, never host/theme/result objects. Bound both
+  // bookkeeping and retained text; unusually long lines bypass retention.
+  if (raw.length <= 4096) {
+    while (widthCache.size >= 4096 || cachedWidthChars + raw.length > MAX_WIDTH_CACHE_CHARS) {
+      const oldest = widthCache.keys().next().value;
+      widthCache.delete(oldest);
+      cachedWidthChars -= oldest.length;
+    }
+    widthCache.set(raw, width);
+    cachedWidthChars += raw.length;
+  }
+  return width;
 }
 
 function takePrefix(text, width) {

package/{render.js → src/ui/render.js}

@@ -11,10 +11,10 @@
  */
 
 import { stripVTControlCharacters } from "node:util";
-import { isString, isObject, isFunction } from "./decode.js";
+import { isString, isObject, isFunction } from "../shared/decode.js";
 import { measureWidth, hardTruncate, clampLine, fitPath, wrapLine } from "./render-measure.js";
 import { novaFramedBlock, novaStatusLine } from "./omp-frame.js";
-import { formatValue } from "./format.js";
+import { formatValue } from "../output/format.js";
 
 export { measureWidth, hardTruncate, clampLine };
 
@@ -42,14 +42,10 @@ function formatDiffRows(diff, theme, maxShown = 6) {
 }
 
 function stripUnsafeControls(value) {
-	let clean = "";
-	for (const character of value) {
-		const codePoint = character.codePointAt(0);
-		const isC0 = codePoint <= 0x08 || codePoint === 0x0b || codePoint === 0x0c || (codePoint >= 0x0e && codePoint <= 0x1f);
-		const isDeleteOrC1 = codePoint >= 0x7f && codePoint <= 0x9f;
-		if (!isC0 && !isDeleteOrC1) clean += character;
-	}
-	return clean;
+	// Exactly the C0/DEL/C1 ranges previously filtered code point by code point.
+	// Native replacement avoids rebuilding every already-clean Unicode string.
+	// eslint-disable-next-line no-control-regex -- intentional terminal-control filtering
+	return value.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, "");
 }
 
 function cleanBlockText(value) {
@@ -195,11 +191,20 @@ function parseDiffLine(rawLine) {
 	return null;
 }
 
+// Text diffs are immutable, even when hosts replace trace snapshots on each frame.
+// Cache only parsed data, not theme, paths or mutable result objects.
+const textDiffCache = new Map();
+let cachedDiffChars = 0;
+const MAX_CACHED_DIFF_CHARS = 1_000_000;
+
 function normalizeTraceDiff(item) {
 	const diff = item?.diff;
 	if (isObject(diff)) return diff;
 	if (!isString(diff) || !diff.trim()) return undefined;
+	const cached = textDiffCache.get(diff);
+	if (cached) return cached;
 	const lines = [];
+	let displayLineCount = 0;
 	let added = 0;
 	let removed = 0;
 	for (const rawLine of cleanBlockText(diff).split("\n")) {
@@ -207,10 +212,21 @@ function normalizeTraceDiff(item) {
 		if (!parsed) continue;
 		if (parsed.type === "add") added += 1;
 		else if (parsed.type === "remove") removed += 1;
-		lines.push(parsed);
+		displayLineCount++;
+		if (lines.length < 24) lines.push(parsed);
 	}
 	if (lines.length === 0) return undefined;
-	return { path: item?.args?.path || "", op: item?.name, added, removed, lines };
+	const parsed = { added, removed, lines, displayLineCount };
+	if (diff.length <= MAX_CACHED_DIFF_CHARS) {
+		while (textDiffCache.size >= 24 || cachedDiffChars + diff.length > MAX_CACHED_DIFF_CHARS) {
+			const oldest = textDiffCache.keys().next().value;
+			textDiffCache.delete(oldest);
+			cachedDiffChars -= oldest.length;
+		}
+		textDiffCache.set(diff, parsed);
+		cachedDiffChars += diff.length;
+	}
+	return parsed;
 }
 
 function operationsFromTrace(trace) {
@@ -305,8 +321,9 @@ function formatOpRow(theme, op, width, isPartial, isError) {
 	return prefix.trimEnd();
 }
 
-function operationsFor(payload, context) {
-	return operationsFromTrace(payload?.trace || context?.state?.trace || []);
+function traceFor(payload, context) {
+	const trace = payload?.trace || context?.state?.trace;
+	return Array.isArray(trace) ? trace : [];
 }
 
 function resultLines(value, width) {
@@ -317,7 +334,7 @@ function resultLines(value, width) {
 function appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError) {
 	for (const op of ops.slice(0, maxOps)) {
 		lines.push(formatOpRow(theme, op, width, isPartial, isError));
-		if (!op.diff || !isObject(op.diff)) continue;
+		if (maxDiffLines === 0 || !op.diff || !isObject(op.diff)) continue;
 		for (const row of formatDiffRows(op.diff, theme, maxDiffLines)) lines.push("  " + row);
 	}
 	if (ops.length > maxOps) lines.push(theme.fg("dim", `  … ${ops.length - maxOps} more calls`));
@@ -338,14 +355,19 @@ function appendTail(lines, theme, payload, expanded, isError, width) {
 	}
 }
 
-function buildBodyLines(theme, width, { payload, context, args, expanded, isPartial, isError }) {
-	const ops = operationsFor(payload, context, args);
+function buildBodyLines(theme, width, { payload, context, expanded, isPartial, isError }) {
+	const trace = traceFor(payload, context);
 	const maxOps = expanded ? 24 : 8;
-	const maxDiffLines = expanded ? 24 : 8;
+	const maxDiffLines = expanded ? 24 : isPartial ? 0 : 8;
+	// Select before parsing diffs: invisible history must not consume a frame.
+	// While running, show current activity rather than the first completed calls.
+	const visible = isPartial ? trace.slice(-maxOps) : trace.slice(0, maxOps);
+	const ops = operationsFromTrace(visible);
 	const lines = [];
 	appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError);
+	if (trace.length > maxOps) lines.push(theme.fg("dim", `  … ${trace.length - maxOps} ${isPartial ? "earlier" : "more"} calls`));
 	appendTail(lines, theme, payload, expanded, isError, width);
-	return { lines, opCount: ops.length };
+	return { lines, opCount: trace.length };
 }
 
 function describeCard(model, opCount) {
@@ -404,7 +426,7 @@ export function renderSupernovaResult(resultArg, optionsArg, themeArg, contextAr
 		contextArg,
 	);
 
-	const payload = result?.details;
+	const payload = result?.details ?? (result?.isError ? { ok: false, error: result.content?.filter(block => block.type === "text").map(block => block.text).join("\n") } : undefined);
 	syncState(context, payload);
 
 	const isError = result?.isError || payload?.ok === false;

package/snap.js

@@ -1,248 +0,0 @@
-
-import * as path from "node:path";
-import { isString } from "./decode.js";
-import { WorkspaceIndex } from "./repo-index.js";
-import { isTestPath } from "./workspace.js";
-
-const STOP_WORDS = new Set([
-  "the", "a", "an", "and", "or", "in", "on", "at", "to", "for", "of", "with",
-  "by", "from", "is", "it", "this", "that", "where", "how", "what", "which",
-  "file", "code", "function", "class", "method", "find", "get", "look",
-]);
-
-export function tokenizeQuery(query) {
-  if (!isString(query) || !query.trim()) {
-    return { tokens: [], wantsTest: false, wantsType: false, wantsDoc: false };
-  }
-
-  const raw = query
-    .replace(/([a-z])([A-Z])/g, "$1 $2")
-    .toLowerCase()
-    .split(/[^a-zA-Z0-9_]+/);
-
-  const tokens = raw.filter((t) => t.length > 1 && !STOP_WORDS.has(t));
-  const queryLower = query.toLowerCase();
-
-  return {
-    tokens: [...new Set(tokens)],
-    wantsTest: queryLower.includes("test") || queryLower.includes("spec"),
-    wantsType: queryLower.includes("type") || queryLower.includes("interface") || queryLower.includes("schema"),
-    wantsDoc: queryLower.includes("doc") || queryLower.includes("readme"),
-  };
-}
-
-const SOURCE_EXT = new Set([".ts", ".js", ".mjs", ".rs", ".py", ".go"]);
-const TYPED_EXT = new Set([".ts", ".d.ts", ".rs", ".go"]);
-const VENDOR_SEGMENTS = ["node_modules/", "dist/", "target/"];
-
-function tokenPathScore(token, basename, pathParts, norm) {
-  if (basename === token || basename.startsWith(token + ".")) return 60;
-  if (basename.includes(token)) return 30;
-  if (pathParts.includes(token)) return 15;
-  if (norm.includes(token)) return 5;
-  return 0;
-}
-
-function extensionBonus(ext, { wantsDoc, wantsType }) {
-  let bonus = 0;
-  if (SOURCE_EXT.has(ext) && !wantsDoc) bonus += 5;
-  if (wantsType && TYPED_EXT.has(ext)) bonus += 10;
-  return bonus;
-}
-
-export function scorePathTopology(filePath, tokens, flags) {
-  const norm = filePath.replaceAll("\\", "/").toLowerCase();
-  const isTest = norm.includes("test") || norm.includes("spec") || norm.includes("__tests__");
-  if (isTest && !flags.wantsTest) return -50;
-  if (!isTest && flags.wantsTest) return -20;
-  if (VENDOR_SEGMENTS.some((segment) => norm.includes(segment))) return -100;
-
-  const basename = path.basename(norm);
-  const pathParts = norm.split(/[^a-zA-Z0-9]+/);
-  let score = extensionBonus(path.extname(norm), flags);
-  for (const token of tokens) score += tokenPathScore(token, basename, pathParts, norm);
-  return score;
-}
-
-function isSkippableLine(lower) {
-  return !lower || lower.startsWith("//") || lower.startsWith("#") || lower.startsWith("*");
-}
-
-/** A line defines a token only when the declared name contains it; `const x = foo(token)` is a mention. */
-function lineScoreFor(lower, tokens, definedName) {
-  let lineScore = 0;
-  for (const token of tokens) {
-    if (!lower.includes(token)) continue;
-    lineScore += definedName.includes(token) ? 40 : 5;
-  }
-  return lineScore;
-}
-
-// Mentions are capped so a file that calls a symbol many times cannot outrank the file that defines it.
-const MAX_MENTION_SCORE = 60;
-
-function scoreContentDefinitions(entry, tokens) {
-  const { lower, defNames } = WorkspaceIndex.linesOf(entry);
-  let defScore = 0;
-  let mentionScore = 0;
-  let bestLine = 1;
-  let bestLineScore = 0;
-  for (let i = 0; i < lower.length; i++) {
-    if (isSkippableLine(lower[i])) continue;
-    const lineScore = lineScoreFor(lower[i], tokens, defNames[i]);
-    if (lineScore > bestLineScore) {
-      bestLineScore = lineScore;
-      bestLine = i + 1;
-    }
-    if (defNames[i]) defScore += lineScore;
-    else mentionScore += lineScore;
-  }
-  return { totalScore: defScore + Math.min(mentionScore, MAX_MENTION_SCORE), bestLine, bestLineScore };
-}
-
-function relativeHasSegment(relativePath, segmentName) {
-  return relativePath.split(path.sep).includes(segmentName);
-}
-
-function relativeHasHiddenSegment(relativePath) {
-  return relativePath.split(path.sep).some((segment) => segment.startsWith(".") && segment.length > 1);
-}
-
-async function listCandidateFiles(dir, includeHidden, index) {
-  return (await index.files(dir, includeHidden)).slice();
-}
-
-function mergePendingPaths(fileList, pendingPaths, dir, includeHidden = false) {
-  const resolvedDir = path.resolve(dir);
-  const seenPaths = new Set(fileList.map((filePath) => path.resolve(filePath)));
-  for (const pendingPath of pendingPaths) {
-    const absolutePath = path.resolve(pendingPath);
-    const relativePath = path.relative(resolvedDir, absolutePath);
-    const escapesDir = relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath);
-    const hiddenRelativePath = relativeHasHiddenSegment(relativePath);
-    if (escapesDir || relativeHasSegment(relativePath, ".git") || (!includeHidden && hiddenRelativePath) || seenPaths.has(absolutePath)) continue;
-    seenPaths.add(absolutePath);
-    fileList.push(absolutePath);
-  }
-  return fileList;
-}
-
-function mergeGrepHits(candidates, grepHits) {
-  const seen = new Set(candidates);
-  for (const h of grepHits) {
-    if (seen.has(h)) continue;
-    seen.add(h);
-    candidates.push(h);
-    if (candidates.length >= 15) break;
-  }
-  return candidates;
-}
-
-function expandCandidatesWithGrep(candidates, fileList, tokens, flags, index) {
-  if (candidates.length >= 5) return candidates;
-  const salient = tokens.filter((t) => t.length > 2).slice(0, 4);
-  const scope = flags.wantsTest ? fileList : fileList.filter((f) => !isTestPath(f));
-  const hits = index.filesContaining(scope, salient, true);
-  mergeGrepHits(candidates, hits);
-  if (candidates.length === 0) return fileList.slice(0, 5);
-  return candidates;
-}
-
-function scoreSurfaceItems(items, tokens, fallbackLine) {
-  let bonus = 0;
-  let best = null;
-  let bestMatches = 0;
-  for (const item of items) {
-    const nameLower = item.name.toLowerCase();
-    const matches = tokens.filter((token) => nameLower.includes(token)).length;
-    if (matches === 0) continue;
-    bonus += matches * (item.isExport ? 80 : 50);
-    if (matches > bestMatches) {
-      bestMatches = matches;
-      best = item;
-    }
-  }
-  return { bonus, signature: best?.signature ?? "", anchorLine: best?.line ?? fallbackLine };
-}
-
-function scoreCandidateContents(candidates, tokens, flags, index, overlayText) {
-  const candidateScores = [];
-  for (const filePath of candidates) {
-    const pending = overlayText(filePath);
-    const entry = pending === undefined ? index.entry(filePath) : WorkspaceIndex.fromText(filePath, pending);
-    if (!entry) continue;
-    const content = entry.text;
-    const { totalScore, bestLine, bestLineScore } = scoreContentDefinitions(entry, tokens);
-    const surface = WorkspaceIndex.surfaceOf(entry);
-    const { bonus: surfaceBonus, signature, anchorLine } = scoreSurfaceItems(surface.items, tokens, bestLine);
-    const lowerPath = filePath.toLowerCase();
-    const isTestFile = lowerPath.includes("test") || lowerPath.includes("spec");
-    const testAdjustment = !isTestFile ? 0 : (flags.wantsTest ? 100 : -200);
-    candidateScores.push({
-      path: filePath,
-      score: totalScore + surfaceBonus + (bestLineScore * 2) + testAdjustment,
-      anchorLine,
-      signature,
-      content,
-    });
-  }
-  candidateScores.sort((a, b) => b.score - a.score);
-  return candidateScores;
-}
-
-function rankCandidates(fileList, tokens, flags, index, overlayText) {
-  const scoredPaths = [];
-  for (const f of fileList) {
-    const score = scorePathTopology(f, tokens, flags);
-    if (score > 0) scoredPaths.push({ path: f, score });
-  }
-  scoredPaths.sort((a, b) => b.score - a.score);
-  const selected = scoredPaths.filter((p) => p.score >= 25).slice(0, 10).map((p) => p.path);
-  const candidates = expandCandidatesWithGrep(selected, fileList, tokens, flags, index);
-  const candidateScores = scoreCandidateContents(candidates, tokens, flags, index, overlayText);
-  return { candidates, candidateScores };
-}
-
-function buildSnapResult(candidates, candidateScores, fileList, root) {
-  const relative = (p) => path.relative(root, p) || p;
-  if (candidateScores.length === 0 || candidateScores[0].score <= 0) {
-    return { path: relative(candidates[0] || fileList[0]), line: 1, signature: "", confidence: 0.3, context: [] };
-  }
-  const best = candidateScores[0];
-  const lines = best.content.split("\n");
-  // Two lines before and four after: enough to confirm the hit; read() is the tool for more.
-  const startLine = Math.max(1, best.anchorLine - 2);
-  const endLine = Math.min(lines.length, best.anchorLine + 4);
-  const context = [];
-  for (let l = startLine; l <= endLine; l++) {
-    const marker = l === best.anchorLine ? "►" : " ";
-    context.push(marker + l + " " + lines[l - 1]);
-  }
-  const confidence = Math.min(0.98, Math.max(0.65, best.score / 150));
-  return {
-    path: relative(best.path),
-    line: best.anchorLine,
-    signature: best.signature,
-    confidence: Number(confidence.toFixed(2)),
-    context,
-  };
-}
-
-export async function executeSnap({ query, searchDir, root, includeHidden = false, index, overlayText = () => undefined, pendingPaths = [] }) {
-  const { tokens, wantsTest, wantsType, wantsDoc } = tokenizeQuery(query);
-  if (tokens.length === 0) {
-    throw new Error("snap requires at least one searchable concept keyword");
-  }
-  const dir = searchDir || process.cwd();
-  if (path.resolve(dir).split(path.sep).includes(".git")) {
-    throw new Error("snap cannot search Git metadata");
-  }
-  const fileList = await listCandidateFiles(dir, includeHidden, index);
-  mergePendingPaths(fileList, pendingPaths, dir, includeHidden);
-  if (fileList.length === 0) {
-    throw new Error(`no files found to search in ${dir}`);
-  }
-  const flags = { wantsTest, wantsDoc, wantsType };
-  const { candidates, candidateScores } = rankCandidates(fileList, tokens, flags, index, overlayText);
-  return buildSnapResult(candidates, candidateScores, fileList, root ?? dir);
-}