pi-supernova 0.8.2 → 0.9.0

package/src/ui/render.js

@@ -1,3 +1,6 @@
+import {normalizeCallRenderArgs,normalizeResultRenderArgs} from './host-render.js';
+export {normalizeCallRenderArgs} from './host-render.js';
+import {formatDiffRows,operationsFromTrace,formatDuration,formatOpRow,cleanBlockText} from './trace.js';
 /**
  * Supernova TUI renderers.
  *
@@ -10,313 +13,13 @@
  * lifecycle never duplicates; mutating operations include bounded inline diffs.
  */
 
-import { stripVTControlCharacters } from "node:util";
-import { isString, isObject, isFunction } from "../shared/decode.js";
-import { measureWidth, hardTruncate, clampLine, fitPath, wrapLine } from "./render-measure.js";
+import { isString, isObject } from "../shared/decode.js";
+import { measureWidth, hardTruncate, clampLine, wrapLine } from "./render-measure.js";
 import { novaFramedBlock, novaStatusLine } from "./omp-frame.js";
 import { formatValue } from "../output/format.js";
 
 export { measureWidth, hardTruncate, clampLine };
 
-function diffGut(theme, item) {
-	const num = item.lineNum || 0;
-
-	if (item.type === "remove") {
-		const gut = theme.fg("toolDiffRemoved", `-${num}`.padStart(5));
-
-		return `${gut}${theme.fg("borderMuted", " │ ")}${theme.fg("toolDiffRemoved", `- ${cleanInlineText(item.text)}`)}`;
-	}
-
-	if (item.type === "add") {
-		const gut = theme.fg("toolDiffAdded", `+${num}`.padStart(5));
-
-		return `${gut}${theme.fg("borderMuted", " │ ")}${theme.fg("toolDiffAdded", `+ ${cleanInlineText(item.text)}`)}`;
-	}
-
-	const gut = theme.fg("dim", ` ${num}`.padStart(5));
-
-	return `${gut}${theme.fg("borderMuted", " │ ")}${theme.fg("toolDiffContext", `  ${cleanInlineText(item.text)}`)}`;
-}
-
-function formatDiffRows(diff, theme, maxShown = 6) {
-	if (!diff || !Array.isArray(diff.lines) || diff.lines.length === 0) return [];
-	const body = [];
-
-	for (const item of diff.lines.slice(0, maxShown)) body.push(diffGut(theme, item));
-	const displayLineCount = Number.isInteger(diff.displayLineCount) ? diff.displayLineCount : diff.lines.length;
-
-	if (displayLineCount > maxShown) {
-		body.push(theme.fg("dim", `      │ … ${displayLineCount - maxShown} more lines`));
-	}
-
-	return body;
-}
-
-function stripUnsafeControls(value) {
-	// 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) {
-	const normalized = stripVTControlCharacters(String(value ?? "")).replace(/\r\n?/g, "\n");
-
-	return stripUnsafeControls(normalized).replace(/[\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, "");
-}
-
-function cleanInlineText(value) {
-	return cleanBlockText(value).replace(/\s*\n\s*/g, " ").trim();
-}
-
-function displayOperation(tool, target, diff, ok, item) {
-	const rawName = cleanInlineText(tool);
-
-	if (!rawName) return null;
-	const normalized = rawName === "apply_patch" ? "patch" : rawName;
-
-	return { tool: normalized, target, diff, ok, ms: item?.ms, exitCode: item?.exitCode, time: item?.time, error: item?.error };
-}
-
-function isTheme(value) {
-	return isObject(value) && isFunction(value.fg);
-}
-
-/**
- * Dual-host renderCall args:
- *   Pi:  (args, theme, context)
- *   OMP: (args, options/renderState, theme)
- */
-export function normalizeCallRenderArgs(a, b, c) {
-	if (isTheme(b)) {
-		const context = isObject(c) ? c : {};
-
-		if (!isObject(context.state)) context.state = {};
-
-		return { args: a, theme: b, context, host: "pi" };
-	}
-
-	if (isTheme(c)) {
-		const options = isObject(b) ? b : {};
-
-		if (!isObject(options.state)) options.state = {};
-
-		const context = {
-			...options,
-			state: options.state,
-			expanded: options.expanded,
-			isPartial: options.isPartial,
-			executionStarted: options.executionStarted,
-			argsComplete: options.argsComplete,
-			lastComponent: options.lastComponent,
-			invalidate: options.invalidate,
-		};
-
-		return { args: a, theme: c, context, host: "omp", options };
-	}
-
-	throw new Error("supernova renderCall: theme missing (expected Pi or OMP signature)");
-}
-
-/**
- * Dual-host renderResult args:
- *   Pi:  (result, {expanded,isPartial}, theme, 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.
- */
-function contextFrom(opts, ctxOrArgs) {
-	if (isObject(ctxOrArgs) && !isTheme(ctxOrArgs)) {
-		if ("lastComponent" in ctxOrArgs || "state" in ctxOrArgs || "invalidate" in ctxOrArgs) return ctxOrArgs;
-	}
-
-	return { state: opts.state, lastComponent: opts.lastComponent };
-}
-
-function isRenderContext(value) {
-	return "lastComponent" in value || "invalidate" in value;
-}
-
-function isToolArgs(value) {
-	return "code" in value || "file" in value || "programs" in value || "timeoutMs" in value;
-}
-
-function detectResultHost(options, ctxOrArgs) {
-	if (isTheme(options)) return "pi";
-
-	if (!isObject(ctxOrArgs)) return "pi";
-
-	if (isRenderContext(ctxOrArgs)) return "pi";
-
-	if (isToolArgs(ctxOrArgs)) return "omp";
-
-	return "pi";
-}
-
-function ensureState(context) {
-	if (!isObject(context.state)) context.state = {};
-
-	return context;
-}
-
-function resultArgs(ctxOrArgs, context) {
-	return ctxOrArgs?.code || ctxOrArgs?.file || ctxOrArgs?.programs ? ctxOrArgs : context.args;
-}
-
-function piResultArgs(result, options, theme, ctxOrArgs) {
-	const opts = isObject(options) ? options : {};
-	const context = ensureState(contextFrom(opts, ctxOrArgs));
-
-	return {
-		result,
-		expanded: !!opts.expanded,
-		isPartial: !!opts.isPartial,
-		theme,
-		context,
-		args: resultArgs(ctxOrArgs, context),
-		host: detectResultHost(options, ctxOrArgs),
-		options: opts,
-	};
-}
-
-function oddballResultArgs(result, theme, themeOrCtx) {
-	const context = ensureState(isObject(themeOrCtx) ? themeOrCtx : {});
-
-	return {
-		result,
-		expanded: !!context.expanded,
-		isPartial: !!context.isPartial,
-		theme,
-		context,
-		args: context.args,
-		host: "pi",
-		options: {},
-	};
-}
-
-function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs) {
-	if (isTheme(themeOrCtx)) return piResultArgs(result, options, themeOrCtx, ctxOrArgs);
-
-	if (isTheme(options)) return oddballResultArgs(result, options, themeOrCtx);
-
-	throw new Error("supernova renderResult: theme missing (expected Pi or OMP signature)");
-}
-
-function batchTarget(paths) {
-	const names = paths.map((p) => String(p).replace(/\\/g, "/").split("/").pop());
-
-	return `${paths.length} files: ${names.join(", ")}`;
-}
-
-const OPERATION_TARGETS = [
-	[(item) => item?.name === "snap", (item, args) => {
-		const query = args.query ? `"${args.query}"` : "";
-
-		if (!args.path) return query;
-
-		return `${query} → ${args.path}`;
-	}],
-	[(item) => item?.name === "search", (item, args) => (args.query ? `"${args.query}"` : "")],
-	[(item, args) => Array.isArray(args.path), (item, args) => batchTarget(args.path)],
-	[(item, args) => args.path, (item, args) => String(args.path)],
-	[(item) => item?.diff?.path, (item) => String(item.diff.path)],
-	[(item, args) => args.target && isString(args.target), (item, args) => args.target],
-	[(item, args) => args.command, (item, args) => String(args.command)],
-	[(item, args) => args.pattern, (item, args) => String(args.pattern)],
-	[(item, args) => args.query, (item, args) => String(args.query)],
-];
-
-function operationTarget(item) {
-	const args = item?.args || {};
-
-	for (const [predicate, formatter] of OPERATION_TARGETS) {
-		if (predicate(item, args)) return formatter(item, args);
-	}
-
-	return "";
-}
-
-function parseDiffLine(rawLine) {
-	const signed = /^([+-])\s*(\d+)\s?(.*)$/.exec(rawLine);
-
-	if (signed) return { type: signed[1] === "+" ? "add" : "remove", lineNum: Number(signed[2]), text: signed[3] };
-	const contextual = /^\s+(\d+)\s?(.*)$/.exec(rawLine);
-
-	if (contextual) return { type: "context", lineNum: Number(contextual[1]), text: contextual[2] };
-
-	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 rememberDiff(diff, parsed) {
-	if (diff.length > MAX_CACHED_DIFF_CHARS) return parsed;
-
-	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 tallyDiffLine(parsed, counts) {
-	if (parsed.type === "add") counts.added += 1;
-	else if (parsed.type === "remove") counts.removed += 1;
-}
-
-function parseTraceDiffText(diff) {
-	const lines = [];
-	const counts = { added: 0, removed: 0, displayLineCount: 0 };
-
-	for (const rawLine of cleanBlockText(diff).split("\n")) {
-		const parsed = parseDiffLine(rawLine);
-
-		if (!parsed) continue;
-		tallyDiffLine(parsed, counts);
-		counts.displayLineCount++;
-
-		if (lines.length < 24) lines.push(parsed);
-	}
-
-	if (lines.length === 0) return undefined;
-
-	return { added: counts.added, removed: counts.removed, lines, displayLineCount: counts.displayLineCount };
-}
-
-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 parsed = parseTraceDiffText(diff);
-
-	return parsed ? rememberDiff(diff, parsed) : undefined;
-}
-
-function operationsFromTrace(trace) {
-	if (!Array.isArray(trace)) return [];
-
-	return trace
-		.map((item) => displayOperation(item?.name || "tool", operationTarget(item), normalizeTraceDiff(item), item?.ok, item))
-		.filter(Boolean);
-}
-
 // The call slot is always empty: the result card owns the whole lifecycle in both hosts.
 const EMPTY_CALL = { render: () => [], invalidate() {} };
 
@@ -329,116 +32,6 @@ export function renderSupernovaCall(a, b, c) {
 	return EMPTY_CALL;
 }
 
-const TOOL_COL = 7;
-
-const DURATION_COL = 6;
-
-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`;
-	const minutes = Math.floor(ms / 60000);
-	const seconds = Math.round((ms % 60000) / 1000);
-
-	return `${minutes}m${String(seconds).padStart(2, "0")}s`;
-}
-
-/** First meaningful line of a shell command plus a count of the hidden remainder. */
-function summarizeCommand(raw) {
-	const lines = cleanBlockText(raw).split("\n").map((line) => line.trim()).filter(Boolean);
-
-	if (lines.length === 0) return "";
-	const first = lines[0].replace(/\s+/g, " ");
-
-	return lines.length > 1 ? `${first} …+${lines.length - 1} lines` : first;
-}
-
-const SHELL_TOOLS = ["bash", "exec"];
-
-const SEARCH_TOOLS = ["snap", "search"];
-
-function formatTarget(op, budget) {
-	if (SHELL_TOOLS.includes(op.tool)) return clampLine(summarizeCommand(op.target), budget);
-	const text = cleanInlineText(op.target);
-
-	if (!text) return "";
-
-	if (SEARCH_TOOLS.includes(op.tool)) return clampLine(text, budget);
-
-	return fitPath(text, budget);
-}
-
-function opMarker(theme, op, isPartial, isError) {
-	if (op.ok === false) return theme.fg("error", "×");
-
-	if (op.mutationAttempt) return theme.fg("warning", "·");
-
-	if (op.ok === true) return theme.fg("success", "✓");
-
-	if (isPartial) return theme.fg("dim", "·");
-
-	if (isError) return theme.fg("error", "×");
-
-	return theme.fg("success", "✓");
-}
-
-function opDuration(op, isPartial) {
-	if (Number.isFinite(op.ms)) return formatDuration(op.ms);
-
-	if (isPartial && op.ok === undefined && Number.isFinite(op.time)) return formatDuration(Date.now() - op.time) + "…";
-
-	return "";
-}
-
-function appendExit(theme, op) {
-	if (!Number.isInteger(op.exitCode)) return { text: "", width: 0 };
-	const exit = `exit ${op.exitCode}`;
-
-	return { text: theme.fg("error", exit) + "  ", width: exit.length + 2 };
-}
-
-function appendDiffCounts(theme, op) {
-	if (!(op.diff && isObject(op.diff))) return { text: "", width: 0 };
-	const added = `+${op.diff.added || 0}`;
-	const removed = `-${op.diff.removed || 0}`;
-
-	return {
-		text: theme.fg("toolDiffAdded", added) + theme.fg("dim", "/") + theme.fg("toolDiffRemoved", removed) + " ",
-		width: added.length + 1 + removed.length + 1,
-	};
-}
-
-function opRowSuffix(theme, op, prefix, budget) {
-	const target = formatTarget(op, budget);
-
-	if (target) return prefix + theme.fg("muted", target);
-
-	if (op.ok === false && op.error) return prefix + theme.fg("error", clampLine(cleanInlineText(op.error), budget));
-
-	return prefix.trimEnd();
-}
-
-/**
- * One aligned row: marker · tool · duration · [exit N] · [+a/-r] · target.
- * Fixed columns keep a ledger of mixed calls scannable at a glance.
- */
-function formatOpRow(theme, op, width, isPartial, isError) {
-	const marker = opMarker(theme, op, isPartial, isError);
-	const toolText = op.tool.slice(0, TOOL_COL).padEnd(TOOL_COL);
-	const tool = theme.fg("syntaxFunction", toolText);
-	const durationText = opDuration(op, isPartial).slice(-DURATION_COL);
-	const duration = theme.fg("dim", durationText.padStart(DURATION_COL));
-	const exit = appendExit(theme, op);
-	const counts = appendDiffCounts(theme, op);
-	const outcome = op.mutationAttempt ? "attempted " : "";
-	const prefix = `${marker} ${tool} ${duration}  ` + exit.text + counts.text + theme.fg("warning", outcome);
-	const used = 2 + toolText.length + 1 + DURATION_COL + 2 + exit.width + counts.width + outcome.length;
-
-	return opRowSuffix(theme, op, prefix, Math.max(1, width - used));
-}
-
 function traceFor(payload, context) {
 	const trace = payload?.trace || context?.state?.trace;
 
@@ -472,13 +65,16 @@ function appendError(lines, theme, payload, _expanded, width) {
 }
 
 function appendMutations(lines, theme, payload, width) {
-	const m = payload?.mutations;
-	if (!m || !(m.committed || m.rolledBack || m.external || m.pendingCommits || m.recoveryFailed)) return;
-	const summary = `file versions: committed=${m.committed || 0} rolledBack=${m.rolledBack || 0}`
-		+ (m.external ? `; external calls attempted=${m.external}` : "")
-		+ (m.pendingCommits ? `; pendingCommits=${m.pendingCommits}` : "")
-		+ (m.recoveryFailed ? "; recovery failed: inspect files" : "");
-	for (const line of resultLines(summary, width)) lines.push(theme.fg(m.rolledBack || m.recoveryFailed ? "warning" : "dim", line));
+  const m = payload?.mutations;
+  if (!m || !["committed", "rolledBack", "external", "pendingCommits", "recoveryFailed"].some(key => m[key])) return;
+  const extra = [
+    [m.external, "; external calls attempted=" + m.external],
+    [m.pendingCommits, "; pendingCommits=" + m.pendingCommits],
+    [m.recoveryFailed, "; recovery failed: inspect files"],
+  ].filter(([enabled]) => enabled).map(([, text]) => text).join("");
+  const summary = "file versions: committed=" + (m.committed || 0) + " rolledBack=" + (m.rolledBack || 0) + extra;
+  const role = m.rolledBack || m.recoveryFailed ? "warning" : "dim";
+  for (const line of resultLines(summary, width)) lines.push(theme.fg(role, line));
 }
 
 function appendResult(lines, theme, payload, expanded, width) {
@@ -526,8 +122,7 @@ function buildBodyLines(theme, width, { payload, context, expanded, isPartial, i
 	const ops = operationsFromTrace(visibleTrace(trace, maxOps, isPartial));
 	// Trace success records an operation, not persistence of every staged version.
 	// Mixed rollback/commit counts cannot safely be attributed to individual rows.
-	for (const op of ops) op.mutationAttempt = op.ok === true && ["write", "edit", "patch"].includes(op.tool)
-		&& (isPartial || isError || payload?.mutations?.rolledBack > 0 || payload?.mutations?.recoveryFailed);
+	for (const op of ops) op.mutationAttempt = mutationAttempt(op, payload, isPartial, isError);
 	const lines = [];
 	appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError);
 	appendOverflow(lines, theme, trace, maxOps, isPartial);
@@ -651,3 +246,8 @@ export function renderSupernovaResult(resultArg, optionsArg, themeArg, contextAr
 
 	return comp;
 }
+
+function mutationAttempt(op, payload, isPartial, isError) {
+  return op.ok === true && ["write", "edit", "patch"].includes(op.tool)
+    && (isPartial || isError || payload?.mutations?.rolledBack > 0 || payload?.mutations?.recoveryFailed);
+}