@linxiraos/pi-tui 1.1.27 → 1.2.1

package/src/tools/todo.ts

@@ -65,11 +65,31 @@ export interface TodoToolDetails {
  * that would collide across unrelated todos. */
 const TODO_DESCRIPTION_MIN_OVERLAP = 6;
 
+/** Bound on {@link normalizedTodoCache}; cleared wholesale when exceeded. */
+const NORMALIZED_TODO_CACHE_LIMIT = 1024;
+const normalizedTodoCache = new Map<string, string>();
+
 function normalizeForTodoMatch(value: string): string {
-	return value
+	let normalized = normalizedTodoCache.get(value);
+	if (normalized !== undefined) return normalized;
+	normalized = value
 		.toLowerCase()
 		.replace(/[^\p{L}\p{N}]+/gu, " ")
 		.trim();
+	if (normalizedTodoCache.size >= NORMALIZED_TODO_CACHE_LIMIT) normalizedTodoCache.clear();
+	normalizedTodoCache.set(value, normalized);
+	return normalized;
+}
+
+/** Match a pre-normalized target against pre-normalized, non-empty candidates. */
+function matchesNormalizedCandidates(target: string, candidates: readonly string[]): boolean {
+	if (!target) return false;
+	for (const candidate of candidates) {
+		if (target === candidate) return true;
+		if (target.length >= TODO_DESCRIPTION_MIN_OVERLAP && candidate.includes(target)) return true;
+		if (candidate.length >= TODO_DESCRIPTION_MIN_OVERLAP && target.includes(candidate)) return true;
+	}
+	return false;
 }
 
 /**
@@ -88,14 +108,12 @@ function normalizeForTodoMatch(value: string): string {
 export function todoMatchesAnyDescription(content: string, descriptions: readonly string[]): boolean {
 	const target = normalizeForTodoMatch(content);
 	if (!target) return false;
+	const candidates: string[] = [];
 	for (const desc of descriptions) {
 		const candidate = normalizeForTodoMatch(desc);
-		if (!candidate) continue;
-		if (target === candidate) return true;
-		if (target.length >= TODO_DESCRIPTION_MIN_OVERLAP && candidate.includes(target)) return true;
-		if (candidate.length >= TODO_DESCRIPTION_MIN_OVERLAP && target.includes(candidate)) return true;
+		if (candidate) candidates.push(candidate);
 	}
-	return false;
+	return matchesNormalizedCandidates(target, candidates);
 }
 
 /** Whether a todo is settled: completed or deliberately abandoned. Shared so
@@ -144,13 +162,16 @@ const COLLAPSED_CLOSED_CONTEXT = 1;
  * 3. When active tasks alone exceed `cap`, only the first `cap` active tasks are
  *    shown and the summary counts the hidden *active* todos, never replacing
  *    them with unrelated pending rows.
+ *
+ * The summary occupies a row, so a summary that would hide exactly one task is
+ * replaced by that task: the selection spends at most `cap + 1` rows.
  */
 function selectWithinCap<T extends { status: TodoStatus }>(
 	base: T[],
 	isMatched: (task: T) => boolean,
 	cap: number,
 ): CollapsedTodoSelection<T> {
-	if (base.length <= cap) return { items: base, summary: "" };
+	if (base.length <= cap + 1) return { items: base, summary: "" };
 
 	const active = base.filter(task => isActiveTodo(task, isMatched));
 	// Only when active work strictly exceeds the cap do we drop pending rows and
@@ -311,24 +332,37 @@ function strikethroughText(text: string): string {
 	return `${STRIKE_START}${text}${STRIKE_END}`;
 }
 
-function partialStrikethrough(text: string, visibleChars: number): string {
+/** Display label for a todo row, with its code points split once for the strike animation. */
+interface TodoLabel {
+	text: string;
+	chars?: string[];
+}
+
+function labelChars(label: TodoLabel): string[] {
+	label.chars ??= [...label.text];
+	return label.chars;
+}
+
+function partialStrikethrough(label: TodoLabel, visibleChars: number): string {
+	const text = label.text;
 	if (visibleChars <= 0) return text;
-	const chars = [...text];
+	const chars = labelChars(label);
 	if (visibleChars >= chars.length) return strikethroughText(text);
 	return `${strikethroughText(chars.slice(0, visibleChars).join(""))}${chars.slice(visibleChars).join("")}`;
 }
 
-function strikeRevealCount(text: string, frame: number | undefined): number | undefined {
+function strikeRevealCount(label: TodoLabel, frame: number | undefined): number | undefined {
 	if (frame === undefined) return undefined;
 	if (frame <= TODO_STRIKE_HOLD_FRAMES) return 0;
-	const chars = [...text];
-	if (chars.length === 0) return undefined;
+	const count = labelChars(label).length;
+	if (count === 0) return undefined;
 	const revealFrame = Math.min(frame - TODO_STRIKE_HOLD_FRAMES, TODO_STRIKE_REVEAL_FRAMES);
-	return Math.ceil((chars.length * revealFrame) / TODO_STRIKE_REVEAL_FRAMES);
+	return Math.ceil((count * revealFrame) / TODO_STRIKE_REVEAL_FRAMES);
 }
 
 function formatTodoLine(
 	item: TodoItem,
+	label: TodoLabel,
 	uiTheme: Theme,
 	prefix: string,
 	completionKeys: Set<string>,
@@ -336,31 +370,27 @@ function formatTodoLine(
 	matched = false,
 ): string {
 	const checkbox = uiTheme.checkbox;
-	// Sanitize only for display. A mirrored Cursor snapshot carries provider text
-	// verbatim, and a label holding ANSI/C0 sequences would otherwise rewrite the
-	// terminal every time the list renders or replays. `item.content` stays raw
-	// everywhere else: it is the identity key the local list is looked up by
-	// (`findTaskByContent`) and what gets persisted.
-	const label = forDisplay(item.content);
+	// `label` is the display-sanitized content (see `forDisplay`); `item.content`
+	// stays raw everywhere else as the identity key and persisted value.
+	const text = label.text;
 	switch (item.status) {
 		case "completed": {
 			const revealCount = completionKeys.has(item.content) ? strikeRevealCount(label, frame) : undefined;
-			const content =
-				revealCount === undefined ? strikethroughText(label) : partialStrikethrough(label, revealCount);
+			const content = revealCount === undefined ? strikethroughText(text) : partialStrikethrough(label, revealCount);
 			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${content}`);
 		}
 		case "in_progress":
-			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${label}`);
+			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${text}`);
 		case "abandoned":
-			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${strikethroughText(label)}`);
+			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${strikethroughText(text)}`);
 		case "blocked": {
 			const note = item.blocker ? `blocked: ${forDisplay(item.blocker)}` : "blocked";
-			return uiTheme.fg("warning", `${prefix}${checkbox.unchecked} ${label} (${note})`);
+			return uiTheme.fg("warning", `${prefix}${checkbox.unchecked} ${text} (${note})`);
 		}
 		default:
 			// A pending todo lit by a live subagent match renders accent, matching
 			// the sticky HUD's convention (#5873).
-			return uiTheme.fg(matched ? "accent" : "dim", `${prefix}${checkbox.unchecked} ${label}`);
+			return uiTheme.fg(matched ? "accent" : "dim", `${prefix}${checkbox.unchecked} ${text}`);
 	}
 }
 
@@ -499,6 +529,7 @@ function describeTodoResult(
 		tool: { title: "Todo", target: `${closed}/${total}`, targetKind: "text" },
 		body: [node("checklist", { mode: "full", phases: todoChecklistPhases(phases, isMatched) }, [], "checklist")],
 		preview: "none",
+		open: true,
 	};
 }
 
@@ -592,6 +623,40 @@ export const todoToolRenderer = {
 			return new Text(`${header}\n  ${uiTheme.fg("dim", fallback)}`, 0, 0);
 		}
 
+		// Everything below is fixed for this result; only the spinner frame and
+		// the live subagent description set vary per frame, so derive labels,
+		// touched phases and normalized match state once and reuse them.
+		const labels = new Map<TodoItem, TodoLabel>();
+		const labelFor = (task: TodoItem): TodoLabel => {
+			let label = labels.get(task);
+			if (!label) {
+				// Sanitize only for display: a mirrored Cursor snapshot carries
+				// provider text verbatim (ANSI/C0 would rewrite the terminal).
+				label = { text: forDisplay(task.content) };
+				labels.set(task, label);
+			}
+			return label;
+		};
+		let touchedComputed = false;
+		let touchedPhases: Set<string> | null = null;
+		let lastDescs: readonly string[] | undefined;
+		let candidates: string[] = [];
+		const matchByContent = new Map<string, boolean>();
+		const syncActiveDescs = (descs: readonly string[]): void => {
+			if (lastDescs === descs) return;
+			if (lastDescs && lastDescs.length === descs.length && lastDescs.every((d, i) => d === descs[i])) {
+				lastDescs = descs;
+				return;
+			}
+			lastDescs = descs;
+			candidates = [];
+			for (const desc of descs) {
+				const candidate = normalizeForTodoMatch(desc);
+				if (candidate) candidates.push(candidate);
+			}
+			matchByContent.clear();
+		};
+
 		return framedToolCard(uiTheme, () => {
 			const { expanded, spinnerFrame } = options;
 			const multiPhase = phases.length > 1;
@@ -599,13 +664,28 @@ export const todoToolRenderer = {
 			// Collapse phases this update didn't touch down to a one-line summary so
 			// a single task flip doesn't redraw every phase's full task list. The
 			// manual expand toggle (and the no-signal fallback) still shows all.
-			const touched = expanded || !multiPhase ? null : computeTouchedPhases(args, phases, completedTasks);
+			let touched: Set<string> | null = null;
+			if (!expanded && multiPhase) {
+				if (!touchedComputed) {
+					touchedPhases = computeTouchedPhases(args, phases, completedTasks);
+					touchedComputed = true;
+				}
+				touched = touchedPhases;
+			}
 			// A pending todo counts as active work when an in-flight subagent is
 			// executing it — the transient result surfaces the same active set the
 			// sticky HUD does (#5873). Empty outside an interactive session.
 			const activeDescs = expanded ? [] : activeTodoDescriptionsProvider();
-			const isMatched = (task: TodoItem): boolean =>
-				activeDescs.length > 0 && todoMatchesAnyDescription(task.content, activeDescs);
+			if (activeDescs.length > 0) syncActiveDescs(activeDescs);
+			const isMatched = (task: TodoItem): boolean => {
+				if (activeDescs.length === 0) return false;
+				let matched = matchByContent.get(task.content);
+				if (matched === undefined) {
+					matched = matchesNormalizedCandidates(normalizeForTodoMatch(task.content), candidates);
+					matchByContent.set(task.content, matched);
+				}
+				return matched;
+			};
 			const bodyLines: string[] = [];
 			for (let p = 0; p < phases.length; p++) {
 				const phase = phases[p];
@@ -631,7 +711,8 @@ export const todoToolRenderer = {
 								items: phase.tasks,
 								expanded,
 								itemType: "todo",
-								renderItem: todo => formatTodoLine(todo, uiTheme, "", completionKeys, spinnerFrame),
+								renderItem: todo =>
+									formatTodoLine(todo, labelFor(todo), uiTheme, "", completionKeys, spinnerFrame),
 							},
 							uiTheme,
 						)
@@ -643,7 +724,15 @@ export const todoToolRenderer = {
 									itemType: "todo",
 									trailingSummary: selection.summary,
 									renderItem: todo =>
-										formatTodoLine(todo, uiTheme, "", completionKeys, spinnerFrame, isMatched(todo)),
+										formatTodoLine(
+											todo,
+											labelFor(todo),
+											uiTheme,
+											"",
+											completionKeys,
+											spinnerFrame,
+											isMatched(todo),
+										),
 								},
 								uiTheme,
 							);

package/src/tools/wait.ts

@@ -275,6 +275,39 @@ function jobsRenderResult(
 	});
 
 	let cached: RenderCache | undefined;
+	// Per-job preview rows are invariant across spinner/shimmer frames (the job
+	// snapshots are frozen for this result), so the envelope strip, flatten and
+	// wrap run once per (job, expanded, width) instead of every animated frame.
+	const previewRows = new Map<JobSnapshot, { expanded: boolean; width: number; lines: readonly string[] }>();
+	const jobPreviewRows = (job: JobSnapshot, expanded: boolean, continuationWidth: number): readonly string[] => {
+		const hit = previewRows.get(job);
+		if (hit !== undefined && hit.expanded === expanded && hit.width === continuationWidth) return hit.lines;
+		const artifactError = job.meta?.artifactError ?? job.artifactError;
+		// Legacy rows did not retain full metadata. Strip the known warning
+		// footer so the dedicated row/root warning remains the only copy.
+		const previewError =
+			artifactError ?? (outputMeta?.source?.type !== "report" ? outputMeta?.artifactError : undefined);
+		const previewMeta = job.meta ?? (previewError ? { artifactError: previewError } : undefined);
+		const preview = flattenStructuredPreview(
+			stripTaskResultEnvelope(
+				stripOutputNotice(job.errorText?.trim() || job.resultText?.trim() || "", previewMeta).trim(),
+			),
+		);
+		const lines: string[] = [];
+		if (preview) {
+			const maxLines = expanded ? PREVIEW_LINES_EXPANDED : PREVIEW_LINES_COLLAPSED;
+			const previewLines = getPreviewLines(
+				preview,
+				maxLines,
+				Math.min(PREVIEW_LINE_WIDTH, continuationWidth),
+				Ellipsis.Unicode,
+			);
+			const tone = job.errorText ? "error" : "dim";
+			for (const pl of previewLines) lines.push(`  ${uiTheme.fg(tone, pl)}`);
+		}
+		previewRows.set(job, { expanded, width: continuationWidth, lines });
+		return lines;
+	};
 	return {
 		render(width: number): readonly string[] {
 			const expanded = options.expanded;
@@ -377,30 +410,7 @@ function jobsRenderResult(
 							);
 						}
 
-						// Legacy rows did not retain full metadata. Strip the known warning
-						// footer so the dedicated row/root warning remains the only copy.
-						const previewError =
-							artifactError ?? (outputMeta?.source?.type !== "report" ? outputMeta?.artifactError : undefined);
-						const previewMeta = job.meta ?? (previewError ? { artifactError: previewError } : undefined);
-
-						const preview = flattenStructuredPreview(
-							stripTaskResultEnvelope(
-								stripOutputNotice(job.errorText?.trim() || job.resultText?.trim() || "", previewMeta).trim(),
-							),
-						);
-						if (preview) {
-							const maxLines = expanded ? PREVIEW_LINES_EXPANDED : PREVIEW_LINES_COLLAPSED;
-							const previewLines = getPreviewLines(
-								preview,
-								maxLines,
-								Math.min(PREVIEW_LINE_WIDTH, continuationWidth),
-								Ellipsis.Unicode,
-							);
-							const tone = job.errorText ? "error" : "dim";
-							for (const pl of previewLines) {
-								lines.push(`  ${uiTheme.fg(tone, pl)}`);
-							}
-						}
+						for (const previewLine of jobPreviewRows(job, expanded, continuationWidth)) lines.push(previewLine);
 						return lines;
 					},
 				},

package/src/tools/web-search.ts

@@ -171,7 +171,7 @@ export function renderSearchResult(
 		if (renderedAnswer.length === 0) {
 			answerLines = [theme.fg("muted", tuiText("wsNoAnswerText", "No answer text returned"))];
 		} else if (args?.maxAnswerLines !== undefined && !expanded) {
-			// CLI compact mode (`omp q`) caps the answer; the TUI passes no cap and shows it in full.
+			// CLI compact mode (`zetacode q`) caps the answer; the TUI passes no cap and shows it in full.
 			// `renderedAnswer` is the Markdown component's shared cache — slice copies before appending.
 			const capped = renderedAnswer.slice(0, args.maxAnswerLines);
 			const remaining = renderedAnswer.length - capped.length;

package/src/tools/write.d.ts

@@ -6,7 +6,7 @@ import { type ProcWriteDetails } from "./proc-render";
 import { type CfgWriteDetails } from "./cfg-render";
 import type { FileDiagnosticsResult } from "./lsp";
 import type { OutputMeta } from "./output-meta";
-import type { NativeToolView, RenderResultOptions, ToolActivityContext, ToolActivitySummary } from "./renderer";
+import type { NativeToolView, RenderResultOptions, ToolActivityContext, ToolActivitySummary, ToolFigure } from "./renderer";
 import { type XdevRenderDispatch, type XdevMountedRenderer } from "./xdev";
 /** Details returned by the write tool for transcript rendering. */
 export interface WriteToolDetails {
@@ -37,6 +37,12 @@ interface WriteResult {
     details?: WriteToolDetails;
     isError?: boolean;
 }
+/**
+ * The fence a file write draws as while its content streams and after: its
+ * extension names a figure language and it has content, closed once the args
+ * are final. None for URL-card writes, or after an error.
+ */
+declare function writeFigure(args: WriteRenderArgs | undefined, result: WriteResult | undefined, options: RenderResultOptions): ToolFigure | undefined;
 declare const writeStreamingPreviewStateKey: unique symbol;
 /**
  * Per-component state for incrementally rendering a streamed write.
@@ -75,7 +81,7 @@ export declare const writeToolRenderer: {
     renderCall(args: WriteRenderArgs, options: RenderResultOptions & WriteStreamingPreviewStateCarrier & {
         renderContext?: WriteRenderContext;
     }, uiTheme: Theme): Component | undefined;
-    renderResult(result: WriteResult, options: RenderResultOptions & {
+    renderResult(result: WriteResult, options: RenderResultOptions & WriteStreamingPreviewStateCarrier & {
         renderContext?: WriteRenderContext;
     }, uiTheme: Theme, args?: WriteRenderArgs): Component;
     describeCall(args: WriteRenderArgs, options: RenderResultOptions & {
@@ -84,6 +90,7 @@ export declare const writeToolRenderer: {
     describeResult(result: WriteResult, options: RenderResultOptions & {
         renderContext?: WriteRenderContext;
     }, args?: WriteRenderArgs): NativeToolView | undefined;
+    figure: typeof writeFigure;
     mergeCallAndResult: true;
     forceFirstResultViewportRepaint: (args: unknown, options: RenderResultOptions) => boolean;
 };