pi-supernova 0.10.1 → 0.11.0

package/src/shared/syntax-context.js

@@ -16,13 +16,19 @@ export function sourceContext(source, line, column, lineBreaks = JS_LINES) {
   if (text === undefined) return "";
   const located = Number.isInteger(column) && column >= 0;
   const position = located ? Math.min(column, text.length) : 0;
+  const {shown,caret} = renderSourceWindow(text, position, located);
+
+  return "\n  " + shown + (caret ? "\n  " + caret : "");
+}
+
+function renderSourceWindow(text, position, located) {
   const start = Math.max(0, Math.min(position - 80, text.length - 160));
   const end = Math.min(text.length, start + 160);
   const prefix = start > 0 ? "…" : "";
   const shown = prefix + displaySource(text.slice(start, end)) + (end < text.length ? "…" : "");
   const caret = located ? " ".repeat(stringWidth(prefix + displaySource(text.slice(start, position)))) + "^" : "";
 
-  return "\n  " + shown + (caret ? "\n  " + caret : "");
+  return {shown,caret};
 }
 
 /** acorn-style error that carries a loc, when it has one. */

package/src/shared/utf8.js

@@ -1,17 +1,15 @@
-/** Strict decode: binary or non-UTF-8 text must fail loudly, never as U+FFFD. */
-export function decodeUtf8Strict(bytes, target) {
-  try { return new TextDecoder("utf-8", { fatal: true }).decode(bytes); }
-  catch {
-    throw new Error("not valid UTF-8 (binary or non-UTF-8 text): " + target + "; inspect or convert it with bash (for example iconv -f latin1 -t utf8 or xxd)");
-  }
+function invalidUtf8(target) {
+  return new Error("not valid UTF-8 (binary or non-UTF-8 text): " + target + "; inspect or convert it with bash (for example iconv -f latin1 -t utf8 or xxd)");
 }
 
-/** Prefix window: the byte cut may split a character, so drop one partial tail. */
-export function decodeUtf8Window(bytes) {
-  for (let cut = 0; cut <= 3 && cut < bytes.length; cut++) {
-    try { return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, bytes.length - cut)); }
-    catch { /* a partial character at the cut is expected */ }
-  }
+/** Strict text fidelity includes the BOM; individual formats may consume it. */
+export function decodeUtf8Strict(bytes, target) {
+  try { return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes); }
+  catch { throw invalidUtf8(target); }
+}
 
-  return bytes.toString("utf8");
+/** Streaming decode omits only an incomplete tail, never corrupt interior bytes. */
+export function decodeUtf8Window(bytes, target = "read window") {
+  try { return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes, { stream: true }); }
+  catch { throw invalidUtf8(target); }
 }

package/src/ui/host-render.js

@@ -66,6 +66,7 @@ function isToolArgs(value) {
 
 function detectResultHost(options, ctxOrArgs) {
   if (isTheme(options) || !isObject(ctxOrArgs) || isRenderContext(ctxOrArgs)) return "pi";
+
   return isToolArgs(ctxOrArgs) ? "omp" : "pi";
 }
 
@@ -82,6 +83,7 @@ function resultArgs(ctxOrArgs, context) {
 function piResultArgs(result, options, theme, ctxOrArgs) {
   const opts = isObject(options) ? options : {};
   const context = ensureState(contextFrom(opts, ctxOrArgs));
+
   return resultRenderModel(result, theme, context, opts, opts, detectResultHost(options, ctxOrArgs), resultArgs(ctxOrArgs, context));
 }
 
@@ -91,6 +93,7 @@ function resultRenderModel(result, theme, context, flags, options, host, args) {
 
 function oddballResultArgs(result, theme, themeOrCtx) {
   const context = ensureState(isObject(themeOrCtx) ? themeOrCtx : {});
+
   return resultRenderModel(result, theme, context, context, {}, "pi", context.args);
 }
 
@@ -101,4 +104,5 @@ function normalizeResultRenderArgs(result, options, themeOrCtx, ctxOrArgs) {
 
 	throw new Error("supernova renderResult: theme missing (expected Pi or OMP signature)");
 }
+
 export {normalizeResultRenderArgs};

package/src/ui/omp-frame.js

@@ -54,10 +54,12 @@ const STATUS_PREFIX = { error: ["error", "✗ "], running: ["dim", "… "] };
 
 function statusHeader(theme, { title, description, state, icon }) {
 	const resolved = icon ?? (state === "error" ? "error" : undefined);
+
 	const fg = (key, text) => {
 		try { return isFunction(theme?.fg) ? theme.fg(key, text) : text; }
 		catch { return text; }
 	};
+
 	const prefixSpec = STATUS_PREFIX[resolved];
 	const prefix = prefixSpec ? fg(prefixSpec[0], prefixSpec[1]) : "";
 	const titleText = fg("accent", title);

package/src/ui/progress.js

@@ -1,6 +1,7 @@
 import {isFunction} from '../shared/decode.js';
 
-const PROGRESS_FRAME_MS = 80;
+// Leave headroom for Pi's own render coalescing while providing ~31Hz live state.
+const PROGRESS_FRAME_MS = 32;
 
 /**
  * Live trace updates for the card. The first update is immediate (seeds the result slot);

package/src/ui/render-measure.js

@@ -102,11 +102,22 @@ function pushWrapSegment(out, current, columns, segment, size, width) {
 
 /** Wrap complete, already-sanitized result text without splitting graphemes. */
 export function wrapLine(line, width) {
+  width = Math.floor(width);
+
   if (width <= 0) return [];
   const text = String(line).replace(/\t/g, "   ");
 
   if (measureWidth(text) <= width) return [text];
   const out = [];
+
+  // Sanitized printable ASCII is one column per UTF-16 unit. Bulk slicing
+  // avoids segmenting every source character; Unicode keeps the grapheme path.
+  if (/^[\x20-\x7e]*$/.test(text)) {
+    for (let start = 0; start < text.length; start += width) out.push(text.slice(start, start + width));
+
+    return out;
+  }
+
   const current = { text: "" };
   let columns = 0;
 

package/src/ui/render.js

@@ -1,6 +1,8 @@
 import {normalizeCallRenderArgs,normalizeResultRenderArgs} from './host-render.js';
+
 export {normalizeCallRenderArgs} from './host-render.js';
-import {formatDiffRows,operationsFromTrace,formatDuration,formatOpRow,cleanBlockText} from './trace.js';
+
+import {formatDiffRows,operationsFromTrace,formatDuration,formatOpRow,cleanBlockText,cleanInlineText} from './trace.js';
 /**
  * Supernova TUI renderers.
  *
@@ -16,7 +18,9 @@ import {formatDiffRows,operationsFromTrace,formatDuration,formatOpRow,cleanBlock
 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";
+import { formatBoundedValue, truncateChars } from "../output/format.js";
+
+const MAX_UI_RESULT_CHARS = 32_000;
 
 export { measureWidth, hardTruncate, clampLine };
 
@@ -38,53 +42,95 @@ function traceFor(payload, context) {
 	return Array.isArray(trace) ? trace : [];
 }
 
-function resultLines(value, width) {
-	const text = isString(value) ? value : formatValue(value);
+function resultLines(value, width, layout) {
+	// Bound display text before Unicode layout. Complete machine-facing values
+	// and the execution evidence remain untouched in result.details.
+	const text = isString(value) ? truncateChars(value, MAX_UI_RESULT_CHARS, "UI preview").text
+		: formatBoundedValue(value, MAX_UI_RESULT_CHARS);
+
+	const clean = cleanBlockText(text);
 
-	return cleanBlockText(text).split("\n").flatMap(line => wrapLine(line, width));
+	if (layout?.width === width && layout.text === clean) return layout.lines;
+	const lines = clean.split("\n").flatMap(line => wrapLine(line, width));
+
+	if (layout) Object.assign(layout, {width, text:clean, lines});
+
+	return lines;
 }
 
-function appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError) {
+function appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError, expanded) {
 	for (const op of ops.slice(0, maxOps)) {
 		lines.push(formatOpRow(theme, op, width, isPartial, isError));
 
-		if (maxDiffLines === 0 || !op.diff || !isObject(op.diff)) continue;
+		if (!expanded || 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`));
+	if (!expanded && maxDiffLines > 0) {
+		const latest = ops.findLast(op => op.diff && isObject(op.diff));
+
+		if (latest) {
+			const label = latest.mutationAttempt || latest.ok === false ? "latest attempted change" : "latest change";
+			lines.push(theme.fg("dim", `── ${label}: ${cleanInlineText(latest.target)} ──`));
+
+			for (const row of formatDiffRows(latest.diff, theme, maxDiffLines)) lines.push("  " + row);
+		}
+	}
 }
 
-function appendError(lines, theme, payload, _expanded, width) {
+function appendError(lines, theme, payload, expanded, width) {
 	const errors = [payload?.error || "error"];
+
 	for (const [i, program] of (payload?.programs ?? []).entries()) {
 		if (program.details?.ok === false) errors.push(`program ${i + 1}: ${program.details.error || resultTextContent(program)}`);
 	}
-	for (const error of errors) for (const line of resultLines("✗ " + cleanBlockText(error), width)) lines.push(theme.fg("error", line));
+
+	let remaining = expanded ? Infinity : 8;
+
+	for (const [i, error] of errors.entries()) {
+		const wrapped = resultLines("✗ " + error, width);
+		const shown = wrapped.slice(0, remaining);
+
+		for (const line of shown) lines.push(theme.fg("error", line));
+		remaining -= shown.length;
+
+		if (!expanded && (shown.length < wrapped.length || (remaining === 0 && i + 1 < errors.length))) {
+			lines.push(theme.fg("dim", "  … more error details (expand)"));
+			break;
+		}
+	}
 }
 
 function appendMutations(lines, theme, payload, width) {
   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("");
+  ].flatMap(([enabled, text]) => (enabled ? [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) {
+function appendResult(lines, theme, payload, expanded, width, layout) {
 	if (expanded) lines.push(theme.fg("dim", "── result ──"));
-	const wrapped = resultLines(payload.result, width);
-	const shown = expanded ? wrapped : wrapped.slice(0, 8);
+	const wrapped = resultLines(payload.result, width, layout);
+	const shown = expanded ? wrapped : wrapped.slice(0, 5);
 
 	for (const line of shown) lines.push(theme.fg("toolOutput", line));
 
-	if (!expanded && wrapped.length > shown.length) lines.push(theme.fg("dim", `  … ${wrapped.length - shown.length} more result lines`));
+	if (!expanded && wrapped.length > shown.length) lines.push(theme.fg("dim", `  … ${wrapped.length - shown.length} more result lines (expand)`));
+
+	if (isString(payload.result) && payload.result.length > MAX_UI_RESULT_CHARS) {
+		lines.push(theme.fg("dim", "  … UI preview clipped; select fields for complete values"));
+	}
 }
 
 function appendLogs(lines, theme, payload, width) {
@@ -93,42 +139,47 @@ function appendLogs(lines, theme, payload, width) {
 	for (const log of payload.logs) for (const line of resultLines(log, width)) lines.push(theme.fg("dim", line));
 }
 
-function appendTail(lines, theme, payload, expanded, isError, width, previewResult) {
+function appendTail(lines, theme, payload, expanded, isError, width, layout, showResult) {
 	if (isError) appendError(lines, theme, payload, expanded, width);
-	else if (payload?.result !== undefined && (expanded || previewResult)) appendResult(lines, theme, payload, expanded, width);
+	else if ((expanded || showResult) && payload?.result !== undefined) appendResult(lines, theme, payload, expanded, width, layout);
 
 	if (expanded && payload?.logs?.length) appendLogs(lines, theme, payload, width);
 }
 
 function bodyLimits(expanded, isPartial) {
-	return { maxOps: expanded ? 24 : 8, maxDiffLines: expanded ? 24 : isPartial ? 0 : 8 };
+	return { maxOps: expanded ? 24 : 8, maxDiffLines: expanded ? 24 : isPartial ? 0 : 5 };
 }
 
-function visibleTrace(trace, maxOps, isPartial) {
-	return isPartial ? trace.slice(-maxOps) : trace.slice(0, maxOps);
+function visibleTrace(trace, maxOps) {
+	// Keep the viewport anchored to the same recent work when the run finishes.
+	return trace.slice(-maxOps);
 }
 
-function appendOverflow(lines, theme, trace, maxOps, isPartial) {
-	if (trace.length > maxOps) lines.push(theme.fg("dim", `  … ${trace.length - maxOps} ${isPartial ? "earlier" : "more"} calls`));
+function appendOverflow(lines, theme, trace, maxOps) {
+	if (trace.length > maxOps) lines.push(theme.fg("dim", `  … ${trace.length - maxOps} earlier calls (expand)`));
 }
 
 function appendEmptyOps(lines, theme, ops, isError, isPartial) {
 	if (ops.length === 0 && !isError && !isPartial) lines.push(theme.fg("dim", "JavaScript-only execution"));
 }
 
-function buildBodyLines(theme, width, { payload, context, expanded, isPartial, isError }) {
+function buildBodyLines(theme, width, { payload, context, expanded, isPartial, isError }, layout) {
 	const trace = traceFor(payload, context);
 	const { maxOps, maxDiffLines } = bodyLimits(expanded, isPartial);
-	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.
+	const ops = operationsFromTrace(visibleTrace(trace, maxOps));
+
+	// Native persistence states follow publication/checkpoint outcomes. Legacy and
+	// captured-tool traces remain conservative where persistence is unknown.
 	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);
+	appendOps(lines, theme, ops, maxOps, maxDiffLines, width, isPartial, isError, expanded);
+	appendOverflow(lines, theme, trace, maxOps);
+
 	if (!isPartial) appendMutations(lines, theme, payload, width);
+
 	if (Array.isArray(payload?.trace)) appendEmptyOps(lines, theme, ops, isError, isPartial);
-	appendTail(lines, theme, payload, expanded, isError, width, ops.length === 0 && !isPartial);
+	// Successful adapter calls stay compact; returned source/JSON is expansion-only.
+	appendTail(lines, theme, payload, expanded, isError, width, layout, ops.length === 0 && !isPartial);
 
 	return { lines, opCount: trace.length };
 }
@@ -136,7 +187,8 @@ function buildBodyLines(theme, width, { payload, context, expanded, isPartial, i
 function describeCard(model, opCount) {
 	const wall = model.payload?.wallMs != null ? formatDuration(model.payload.wallMs) : "";
 	const calls = opCount > 0 ? `${opCount} call${opCount === 1 ? "" : "s"}` : "";
-	const status = model.isError ? "failed" : model.isPartial ? "running" : calls ? "" : "complete";
+	const saved = model.payload?.mutations?.committed > 0 || traceFor(model.payload, model.context).some(row=>row.mutationState === "saved");
+	const status = model.isError ? saved ? "partial · failed step" : "failed" : model.isPartial ? "running" : "complete";
 
 	return [calls, status, wall].filter(Boolean).join(" · ");
 }
@@ -179,6 +231,10 @@ function renderCardLines(theme, model, width, view) {
 }
 
 class UnifiedResultCard {
+	// Retain only one bounded, unstyled result layout per card. Theme invalidation
+	// still repaints every row; content or column changes replace the geometry.
+	resultLayout = {};
+
 	set(theme, model) {
 		this.theme = theme;
 		this.model = model;
@@ -193,7 +249,7 @@ class UnifiedResultCard {
 		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 view = buildBodyLines(theme, Math.max(1, width - 4), model, this.resultLayout);
 		const lines = renderCardLines(theme, model, width, view);
 		this.cache = { width, lines };
 
@@ -215,7 +271,9 @@ function resultTextContent(result) {
 
 function payloadFromResult(result, hostError) {
 	const payload = result?.details;
+
 	if (hostError) return {...payload, ok:false, error:payload?.error || resultTextContent(result) || "tool execution failed"};
+
 	return payload ?? {result:resultTextContent(result)};
 }
 
@@ -236,6 +294,7 @@ export function renderSupernovaResult(resultArg, optionsArg, themeArg, contextAr
 		themeArg,
 		contextArg,
 	);
+
 	// Pi omits isError from result and supplies it through render context.
 	const hostError = result?.isError === true || context?.isError === true || options?.isError === true;
 	const payload = payloadFromResult(result, hostError);
@@ -248,6 +307,8 @@ export function renderSupernovaResult(resultArg, optionsArg, themeArg, contextAr
 }
 
 function mutationAttempt(op, payload, isPartial, isError) {
+  if (op.mutationState) return op.mutationState !== "saved";
+
   return op.ok === true && ["write", "edit", "patch"].includes(op.tool)
     && (isPartial || isError || payload?.mutations?.rolledBack > 0 || payload?.mutations?.recoveryFailed);
 }

package/src/ui/trace.js

@@ -5,6 +5,7 @@ import {clampLine,fitPath} from './render-measure.js';
 function diffGut(theme, item) {
   const [sign, color, textColor] = DIFF_STYLES.get(item.type) ?? [" ", "dim", "toolDiffContext"];
   const gutter = theme.fg(color, (sign + (item.lineNum || 0)).padStart(5));
+
   return gutter + theme.fg("borderMuted", " │ ") + theme.fg(textColor, sign + " " + cleanInlineText(item.text));
 }
 
@@ -45,7 +46,7 @@ function displayOperation(tool, target, diff, ok, item) {
 	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 };
+	return { tool: normalized, target, diff, ok, ms: item?.ms, exitCode: item?.exitCode, time: item?.time, error: item?.error, mutationState: item?.mutationState };
 }
 
 function batchTarget(paths) {
@@ -206,12 +207,13 @@ function formatTarget(op, budget) {
 function opMarker(theme, op, isPartial, isError) {
   const status = [
     [op.ok === false, "error", "×"],
-    [op.mutationAttempt, "warning", "·"],
+    [op.mutationAttempt || op.mutationState === "rolled back" || op.mutationState === "uncertain", "warning", "·"],
     [op.ok === true, "success", "✓"],
     [isPartial, "dim", "·"],
     [isError, "error", "×"],
     [true, "success", "✓"],
   ].find(([matches]) => matches);
+
   return theme.fg(status[1], status[2]);
 }
 
@@ -263,13 +265,14 @@ function formatOpRow(theme, op, width, isPartial, isError) {
 	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 outcome = op.mutationState ? op.mutationState + " " : op.mutationAttempt ? "attempted " : "";
+	const prefix = `${marker} ${tool} ${duration}  ` + exit.text + counts.text + theme.fg(op.mutationState === "saved" ? "success" : "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));
 }
-export { formatDiffRows, operationsFromTrace, formatDuration, formatOpRow, cleanBlockText };
+
+export { formatDiffRows, operationsFromTrace, formatDuration, formatOpRow, cleanBlockText, cleanInlineText };
 
 const DIFF_STYLES = new Map([
   ["remove", ["-", "toolDiffRemoved", "toolDiffRemoved"]],