@quandev104/pi-style 0.2.0 → 0.2.2

package/extension-src/pi-style/features/status-line/index.ts

@@ -110,6 +110,37 @@ function separatorsFor(config: NormalizedPiStyleConfig, theme: ResolvedTheme): s
 	return theme.apply("separator", style);
 }
 
+/** Per-(theme, config) derived values shared across status-line renders. */
+interface ThemeAssets {
+	readonly resolved: ResolvedTheme;
+	readonly separator: string;
+}
+/** Resolved theme + separator keyed by Pi theme identity then config identity; a fresh configure() object misses naturally. */
+const themeAssetsCache = new WeakMap<ActivePiTheme, WeakMap<NormalizedPiStyleConfig, ThemeAssets>>();
+function themeAssetsFor(activeTheme: ActivePiTheme, config: NormalizedPiStyleConfig): ThemeAssets {
+	let byConfig = themeAssetsCache.get(activeTheme);
+	if (!byConfig) {
+		byConfig = new WeakMap();
+		themeAssetsCache.set(activeTheme, byConfig);
+	}
+	let assets = byConfig.get(config);
+	if (!assets) {
+		const resolved = resolveTheme(
+			activeTheme.colors || activeTheme.fg
+				? {
+						...(activeTheme.colors ? { colors: activeTheme.colors } : {}),
+						// Call through the theme instance so `this` binds correctly inside Pi's fg().
+						...(activeTheme.fg ? { fg: (color: string, text: string) => activeTheme.fg?.(color, text) ?? text } : {}),
+					}
+				: undefined,
+			config,
+		);
+		assets = { resolved, separator: separatorsFor(config, resolved) };
+		byConfig.set(config, assets);
+	}
+	return assets;
+}
+
 export function installStatusLine(options: StatusLineInstallOptions): StatusLineInstallation {
 	const existing = installationMap(options.host).get(options.generation);
 	if (existing) return existing;
@@ -143,18 +174,9 @@ export function installStatusLine(options: StatusLineInstallOptions): StatusLine
 
 	const render = (activeTheme: ActivePiTheme, width: number, secondary: boolean): string[] => {
 		if (width <= 0 || !config.enabled || !config.statusLine.enabled) return [];
-		const resolved = resolveTheme(
-			activeTheme.colors || activeTheme.fg
-				? {
-						...(activeTheme.colors ? { colors: activeTheme.colors } : {}),
-						// Call through the theme instance so `this` binds correctly inside Pi's fg().
-						...(activeTheme.fg ? { fg: (color: string, text: string) => activeTheme.fg?.(color, text) ?? text } : {}),
-					}
-				: undefined,
-			config,
-		);
+		const { resolved, separator } = themeAssetsFor(activeTheme, config);
 		const result = renderStatus(config.statusLine.layout, effectiveSnapshot(snapshot), width, {
-			separator: separatorsFor(config, resolved),
+			separator,
 			segments,
 			theme: resolved,
 			options: {
@@ -241,12 +263,20 @@ export function installStatusLine(options: StatusLineInstallOptions): StatusLine
 		(secondary: boolean): WidgetFactory =>
 		(tui, theme) => {
 			const currentTheme = theme;
+			// Per-component render cache: Pi repaints widgets on every frame
+			// (keystrokes, streaming chunks, tickers). Same width without an
+			// invalidate() (snapshot update / configure / footer-branch change)
+			// means the previous lines are still current; return them as-is.
+			let renderCache: { width: number; lines: string[] } | undefined;
 			const component: RenderComponent = {
 				render(width) {
+					if (renderCache?.width === width) return renderCache.lines;
 					const lines = render(currentTheme, width, secondary);
+					renderCache = { width, lines };
 					return lines;
 				},
 				invalidate() {
+					renderCache = undefined;
 					// Pi supplies a fresh theme to the factory on theme replacement. Do not retain
 					// pre-rendered ANSI strings; the next render reads the current component theme.
 					primaryComponent = secondary ? primaryComponent : component;

package/extension-src/pi-style/features/tools/bash-execution.ts

@@ -19,6 +19,7 @@ import {
 	boxLine,
 	boxWidth,
 	formatBoxedRunningStatus,
+	themeCacheKey,
 } from "../../shared/box.js";
 import { getThemeExtra } from "../../shared/theme-extras.js";
 
@@ -30,6 +31,11 @@ export function setBashExecutionTheme(theme: BoxTheme | undefined): void {
 }
 
 /** Structural view of the native BashExecutionComponent as used by the patch. */
+interface BashExecutionRenderCache {
+	key: string;
+	lines: string[];
+}
+
 interface BashExecutionInstance {
 	command: string;
 	status: "running" | "cancelled" | "error" | "complete";
@@ -37,6 +43,7 @@ interface BashExecutionInstance {
 	contentContainer: { render(width: number): string[] };
 	/** Wall-clock start captured on the first boxed render for the live `◌ Running · Ns` footer. */
 	piStyleStart?: number;
+	piStyleRenderCache?: BashExecutionRenderCache;
 }
 
 const TOP_LEFT = "╭";
@@ -92,13 +99,15 @@ export function renderBashExecutionBox(instance: unknown, args: unknown[]): stri
 	try {
 		if (host.piStyleStart === undefined) host.piStyleStart = Date.now();
 		const renderedWidth = boxWidth(width);
+		const cacheKey = `${themeCacheKey(theme)}|${width}|${host.status}|${host.exitCode ?? ""}|${host.command}`;
+		if (host.status !== "running" && host.piStyleRenderCache?.key === cacheKey) return host.piStyleRenderCache.lines;
 		const inner = boxInnerWidth(renderedWidth);
 		// The native Text children render one leading padding space per line;
 		// drop it so boxLine's own side padding produces symmetric borders.
 		const wrapped = content
 			.render(inner)
 			.map((line) => boxLine(theme, line.startsWith(" ") ? line.slice(1) : line, renderedWidth));
-		return [
+		const lines = [
 			"",
 			boxLabeledBorder(theme, TOP_LEFT, TOP_RIGHT, bashBoxTitle(theme, host), undefined, renderedWidth),
 			boxBlankLine(theme, renderedWidth),
@@ -106,6 +115,8 @@ export function renderBashExecutionBox(instance: unknown, args: unknown[]): stri
 			boxBlankLine(theme, renderedWidth),
 			boxLabeledBorder(theme, BOTTOM_LEFT, BOTTOM_RIGHT, bashBoxFooter(theme, host), undefined, renderedWidth),
 		];
+		if (host.status !== "running") host.piStyleRenderCache = { key: cacheKey, lines };
+		return lines;
 	} catch {
 		return undefined;
 	}

package/extension-src/pi-style/features/tools/boxed/bash.ts

@@ -15,6 +15,7 @@ import {
 	renderBoxedToolResult,
 	replaceTabs,
 	shortenPath,
+	themeCacheKey,
 } from "../../../shared/box.js";
 import { safeTruncateToWidth, truncateAtCodePointBoundary } from "../../../shared/render-budget.js";
 import { parseSimpleBashCommand } from "./command-shape.js";
@@ -52,6 +53,7 @@ import {
 } from "./output-tree.js";
 import {
 	getStateElapsedMs,
+	getToolsRenderCacheSignature,
 	getToolsRenderConfig,
 	isResultSeen,
 	markResultSeen,
@@ -59,7 +61,14 @@ import {
 	startElapsedTicker,
 	stopElapsedTicker,
 } from "./session-config.js";
-import { type BoxedToolContext, type BoxedToolDefinition, noteBoxedCallState, noteExecutionStart } from "./shared.js";
+import {
+	type BoxedToolContext,
+	type BoxedToolDefinition,
+	getRenderCacheKey,
+	memoizedStateComponent,
+	noteBoxedCallState,
+	noteExecutionStart,
+} from "./shared.js";
 
 const MAX_LINE_CHARS = 2000;
 const ESC = "\x1b";
@@ -179,6 +188,38 @@ function countNewlines(text: string, from: number, to: number): number {
 	return count;
 }
 
+/** Index just past the `need`-th newline counted backwards from `end` (0 when
+ *  the window holds fewer), so only `text.slice(index, end)` needs further
+ *  processing. Plain char scan, no allocation. */
+function findBackwardLineStart(text: string, need: number, end: number = text.length): number {
+	let found = 0;
+	for (let i = end - 1; i >= 0; i--) {
+		if (text.charCodeAt(i) === 10 && ++found >= need) return i + 1;
+	}
+	return 0;
+}
+
+/** Whitespace per `String.prototype.trim` (superset of ASCII blank/line
+ *  terminators); anything else counts as visible output. */
+function isOutputWhitespaceCode(code: number): boolean {
+	if (code === 0x20 || (code >= 0x09 && code <= 0x0d)) return true;
+	if (code === 0x85 || code === 0xa0 || code === 0x1680) return true;
+	if (code >= 0x2000 && code <= 0x200a) return true;
+	return code === 0x2028 || code === 0x2029 || code === 0x202f || code === 0x205f || code === 0x3000 || code === 0xfeff;
+}
+
+/** End index (exclusive) of the last non-whitespace character in `text` — the
+ *  streaming equivalent of `stripAnsi(text).trimEnd()`: trailing blank lines and
+ *  padding never push the visible tail out of the processing window. ANSI
+ *  escape bytes count as non-whitespace; a slice ending inside one still
+ *  strips correctly downstream. */
+function lastVisibleEnd(text: string): number {
+	for (let i = text.length - 1; i >= 0; i--) {
+		if (!isOutputWhitespaceCode(text.charCodeAt(i))) return i + 1;
+	}
+	return 0;
+}
+
 function stripBashToolNoticeLines(text: string): string {
 	const filteredLines = text
 		.replace(/\r/g, "")
@@ -379,8 +420,19 @@ function renderBashStreamingResult(
 	options: { expanded: boolean },
 	context: BoxedToolContext,
 ): Component {
-	const body = stripBashToolNoticeLines(stripAnsi(raw));
-	const hasOutput = body.trim().length > 0;
+	// Tail-only processing: the preview collapses to maxCollapsedLines lines
+	// anyway, so only the last maxCollapsedLines + 10 raw lines (the same headroom
+	// the final collapsed scan uses, covering notice lines stripped from the
+	// tail) get ANSI stripping/truncation work, and trailing blank lines never
+	// push real content out of the window (the raw-string equivalent of the old
+	// whole-buffer stripAnsi + trimEnd). Streaming passes stay O(tail) as the
+	// output grows instead of re-stripping the whole buffer each pass.
+	const contentEnd = lastVisibleEnd(raw);
+	const hasOutput = contentEnd > 0;
+	const tailStart = hasOutput
+		? findBackwardLineStart(raw, getToolsRenderConfig().maxCollapsedLines + 10, contentEnd)
+		: 0;
+	const body = stripBashToolNoticeLines(stripAnsi(raw.slice(tailStart, contentEnd)));
 	const elapsed = getStateElapsedMs(context.state);
 	const emptyLines: string[] = [theme.fg("dim", "No output received yet")];
 	if (!hasOutput && isInteractiveCommand(context?.args?.command) && (elapsed ?? 0) >= 1000) {
@@ -420,17 +472,7 @@ function renderBashFinalResult(
 	if (!options.expanded) {
 		// Collapsed: only process the tail of the output (notices stripped per line).
 		const scanLines = getToolsRenderConfig().maxCollapsedLines + 10;
-		let nlCount = 0;
-		let tailStart = 0;
-		for (let i = statusStripped.length - 1; i >= 0; i--) {
-			if (statusStripped.charCodeAt(i) === 10) {
-				nlCount++;
-				if (nlCount >= scanLines) {
-					tailStart = i + 1;
-					break;
-				}
-			}
-		}
+		const tailStart = findBackwardLineStart(statusStripped, scanLines);
 		const tail = stripBashToolNoticeLines(stripAnsi(statusStripped.slice(tailStart)));
 		const totalLinesBefore = tailStart > 0 ? countNewlines(statusStripped, 0, tailStart) : 0;
 		const preview = createBashResultPreview(theme, tail, options, outputColor);
@@ -499,17 +541,7 @@ function createBashResultPreview(
 			if (!expanded) {
 				// Collapsed: only process the tail of the output
 				const needed = cfg.maxCollapsedLines;
-				let totalNewlines = 0;
-				let scanFrom = 0; // default: take full text if fewer than needed newlines
-				for (let i = text.length - 1; i >= 0; i--) {
-					if (text.charCodeAt(i) === 10) {
-						totalNewlines++;
-						if (totalNewlines === needed) {
-							scanFrom = i + 1;
-							break;
-						}
-					}
-				}
+				const scanFrom = findBackwardLineStart(text, needed); // full text when fewer newlines
 
 				if (text.length === 0) {
 					cacheKey = cacheId;
@@ -539,10 +571,14 @@ function createBashResultPreview(
 				return cacheLines;
 			}
 
-			// Expanded: process all lines
+			// Expanded: only the tail lines the expanded budget can show receive
+			// clamp/truncate/color work; earlier lines collapse into one `… N earlier
+			// lines` head row, so per-line cost scales with maxExpandedLines instead
+			// of the full output.
 			const normalized = replaceTabs(text);
-			const logicalLines = normalized.split("\n").map((l) => clampLineLength(l));
-			const hasOutput = !(logicalLines.length === 1 && logicalLines[0] === "");
+			const rawLines = normalized.split("\n");
+			const totalLines = rawLines.length;
+			const hasOutput = !(totalLines === 1 && rawLines[0] === "");
 
 			if (!hasOutput) {
 				cacheKey = cacheId;
@@ -550,17 +586,17 @@ function createBashResultPreview(
 				return cacheLines;
 			}
 
-			const truncatedLines = logicalLines.map((line) => safeTruncateToWidth(line, bodyWidth, "…"));
-			const expandedLines = truncatedLines.length === 1 && truncatedLines[0] === "" ? [] : truncatedLines;
 			const applyColor = (l: string) =>
 				color === "error"
 					? formatToolOutputLine(theme, l, "error")
 					: cfg.dimOutput
 						? formatToolOutputLine(theme, l)
 						: formatToolOutputLine(theme, l, "text");
-			if (cfg.maxExpandedLines > 0 && expandedLines.length > cfg.maxExpandedLines) {
-				const truncated = expandedLines.slice(-cfg.maxExpandedLines).map(applyColor);
-				const remaining = expandedLines.length - cfg.maxExpandedLines;
+			const renderRawLine = (line: string) => safeTruncateToWidth(clampLineLength(line), bodyWidth, "…");
+
+			if (cfg.maxExpandedLines > 0 && totalLines > cfg.maxExpandedLines) {
+				const truncated = rawLines.slice(-cfg.maxExpandedLines).map((line) => applyColor(renderRawLine(line)));
+				const remaining = totalLines - cfg.maxExpandedLines;
 				truncated.unshift(theme.fg("dim", `… ${remaining} earlier lines`));
 				cacheKey = cacheId;
 				cacheLines = truncated;
@@ -568,7 +604,7 @@ function createBashResultPreview(
 			}
 
 			cacheKey = cacheId;
-			cacheLines = expandedLines.map(applyColor);
+			cacheLines = rawLines.map((line) => applyColor(renderRawLine(line)));
 			return cacheLines;
 		},
 	};
@@ -754,13 +790,25 @@ function parseBashTreeOutput(cls: BashTreeClass, output: string): ParsedBashTree
 	return { matches };
 }
 
+type FinalSemanticRenderCache = {
+	key: string;
+	lines: string[];
+};
+
 interface BashTreeState {
-	readonly cls: BashSemanticClass;
+	cls: BashSemanticClass;
 	/** Raw command, so the call panel can render the boxed bash call on fallback. */
-	readonly command: string;
+	command: string;
 	/** `parsed` once the result arrives; `fallback` when the boxed shell takes over. */
 	parsed?: ParsedSemantic;
 	fallback?: boolean;
+	finished: boolean;
+	revision: number;
+	renderCache?: FinalSemanticRenderCache;
+	/** Raw output length at the last streaming parse attempt: partial passes
+	 *  with smaller growth than PARTIAL_REPARSE_THRESHOLD skip the re-parse (the
+	 *  final pass always parses the settled output in full). */
+	lastParsedLength?: number;
 }
 
 /** Classified semantic command: a bash tree (ls/find/grep), a git card, or a
@@ -817,6 +865,11 @@ function isGitActionClass(cls: BashSemanticClass): boolean {
 	return !isBashTreeClass(cls) && (cls as GitSemanticClass).kind === "action";
 }
 
+/** Minimum raw-output growth (chars) before a streaming partial pass re-parses
+ *  a live tree command's output; smaller deltas keep the current tree until the
+ *  final pass re-parses everything. */
+const PARTIAL_REPARSE_THRESHOLD = 4096;
+
 function parseSemanticOutput(cls: BashSemanticClass, output: string): ParsedSemantic | null {
 	if (isBashTreeClass(cls)) return parseBashTreeOutput(cls, output);
 	if (isGhClass(cls)) return parseGhOutput(cls, output);
@@ -879,29 +932,37 @@ function renderSemanticPanel(theme: BoxTheme, toolCallId: string, context: Boxed
 		invalidate() {},
 		render(width: number): string[] {
 			if (!state) return [];
-			if (state.fallback) {
-				return renderBoxedBashCall(
-					theme,
-					state.command.split("\n"),
-					context,
-					bashWidthKey(state.command, context?.args?.timeout),
-				).render(width);
-			}
-			if (isBashTreeClass(state.cls)) {
-				const treeState: { cls: BashTreeClass; parsed?: ParsedBashTree } = { cls: state.cls };
-				if (state.parsed !== undefined) treeState.parsed = state.parsed as ParsedBashTree;
-				return renderBashTreeLines(theme, treeState, width);
-			}
-			// Git classes only ever carry git parsed values (parseSemanticOutput
-			// dispatches on the class), so the narrowed cast is exact.
-			if (isGhClass(state.cls)) {
-				const ghState: { cls: GhSemanticClass; parsed?: GhParsedSemantic } = { cls: state.cls };
-				if (state.parsed !== undefined) ghState.parsed = state.parsed as GhParsedSemantic;
-				return renderGhCardLines(theme, ghState, width);
-			}
-			const gitState: { cls: GitSemanticClass; parsed?: GitParsedSemantic } = { cls: state.cls };
-			if (state.parsed !== undefined) gitState.parsed = state.parsed as GitParsedSemantic;
-			return renderGitCardLines(theme, gitState, width);
+			const renderFresh = () => {
+				if (state.fallback) {
+					return renderBoxedBashCall(
+						theme,
+						state.command.split("\n"),
+						context,
+						bashWidthKey(state.command, context?.args?.timeout),
+					).render(width);
+				}
+				if (isBashTreeClass(state.cls)) {
+					const treeState: { cls: BashTreeClass; parsed?: ParsedBashTree } = { cls: state.cls };
+					if (state.parsed !== undefined) treeState.parsed = state.parsed as ParsedBashTree;
+					return renderBashTreeLines(theme, treeState, width);
+				}
+				// Git classes only ever carry git parsed values (parseSemanticOutput
+				// dispatches on the class), so the narrowed cast is exact.
+				if (isGhClass(state.cls)) {
+					const ghState: { cls: GhSemanticClass; parsed?: GhParsedSemantic } = { cls: state.cls };
+					if (state.parsed !== undefined) ghState.parsed = state.parsed as GhParsedSemantic;
+					return renderGhCardLines(theme, ghState, width);
+				}
+				const gitState: { cls: GitSemanticClass; parsed?: GitParsedSemantic } = { cls: state.cls };
+				if (state.parsed !== undefined) gitState.parsed = state.parsed as GitParsedSemantic;
+				return renderGitCardLines(theme, gitState, width);
+			};
+			if (!state.finished) return renderFresh();
+			const cacheKey = [themeCacheKey(theme), getToolsRenderCacheSignature(), width, state.revision].join("|");
+			if (state.renderCache?.key === cacheKey) return state.renderCache.lines;
+			const lines = renderFresh();
+			state.renderCache = { key: cacheKey, lines };
+			return lines;
 		},
 	};
 }
@@ -911,7 +972,27 @@ export const bashTool: BoxedToolDefinition = {
 		noteExecutionStart(context);
 		const cls = classifyBashSemantic(String(args?.command ?? ""));
 		if (cls) {
-			semanticStates.set(context.toolCallId, { cls, command: String(args?.command ?? "") });
+			const command = String(args?.command ?? "");
+			const existing = semanticStates.get(context.toolCallId);
+			if (existing) {
+				if (existing.command !== command || existing.cls.kind !== cls.kind) {
+					delete existing.parsed;
+					delete existing.fallback;
+					existing.finished = false;
+					existing.revision++;
+					delete existing.renderCache;
+					delete existing.lastParsedLength;
+				}
+				existing.command = command;
+				existing.cls = cls;
+			} else {
+				semanticStates.set(context.toolCallId, {
+					cls,
+					command,
+					finished: false,
+					revision: 0,
+				});
+			}
 			return renderSemanticPanel(theme, context.toolCallId, context);
 		}
 		noteBoxedCallState(context);
@@ -936,15 +1017,34 @@ export const bashTool: BoxedToolDefinition = {
 			}
 			if (!options.isPartial || isBashTreeClass(cls)) {
 				const output = stripBashToolNoticeLines(stripAnsi(getTextOutput(result)));
-				const parsed = parseSemanticOutput(cls, output);
 				const state = semanticStates.get(context.toolCallId);
+				// Live tree classes re-parse on streaming passes, but only once the raw
+				// output grew ≥ PARTIAL_REPARSE_THRESHOLD chars since the last parse
+				// attempt: re-parsing the full buffer on every partial pass made
+				// streaming O(n²). Small deltas keep the current tree; the final pass
+				// always re-parses, so the settled registry state matches the ungated
+				// path byte for byte.
+				const shouldParse =
+					!options.isPartial ||
+					state === undefined ||
+					state.lastParsedLength === undefined ||
+					output.length - state.lastParsedLength >= PARTIAL_REPARSE_THRESHOLD;
+				const parsed = shouldParse ? parseSemanticOutput(cls, output) : undefined;
 				if (parsed) {
-					if (state) state.parsed = parsed;
-					else
+					if (state) {
+						state.parsed = parsed;
+						state.finished = !options.isPartial;
+						state.revision++;
+						delete state.renderCache;
+						if (options.isPartial) state.lastParsedLength = output.length;
+					} else
 						semanticStates.set(context.toolCallId, {
 							cls,
 							command: String(context?.args?.command ?? ""),
 							parsed,
+							finished: !options.isPartial,
+							revision: 0,
+							...(options.isPartial ? { lastParsedLength: output.length } : {}),
 						});
 					// `git diff` / `git show` render a boxed adaptive-diff result (one frame
 					// per file); `gh run view --job=<id>` renders a boxed log result. Every
@@ -958,10 +1058,26 @@ export const bashTool: BoxedToolDefinition = {
 					}
 					return EMPTY_BASH_TREE_RESULT;
 				}
+				if (!shouldParse) {
+					// Skipped re-parse (sub-threshold growth): keep the current panel. A
+					// live parsed tree still owns the display (the call panel renders it, the
+					// result adds nothing); a fallback keeps streaming raw output into the
+					// open box below.
+					if (state?.parsed !== undefined) return EMPTY_BASH_TREE_RESULT;
+				}
 				// Unparseable output (ls -l, raw rg summary, non-git output): the boxed
 				// shell owns the result; flag the call panel to render nothing so the
-				// two don't duplicate.
-				if (state) state.fallback = true;
+				// two don't duplicate. Skipped passes (sub-threshold growth) leave the
+				// current panel untouched.
+				if (shouldParse) {
+					if (state) {
+						state.fallback = true;
+						state.finished = !options.isPartial;
+						state.revision++;
+						delete state.renderCache;
+						if (options.isPartial) state.lastParsedLength = output.length;
+					}
+				}
 			}
 		} else if (options.isPartial) {
 			startElapsedTicker(context.state, context.invalidate);
@@ -976,6 +1092,19 @@ export const bashTool: BoxedToolDefinition = {
 			if (firstResultPass) return EMPTY_BASH_RESULT;
 			return renderBashStreamingResult(theme, raw, options, context);
 		}
-		return renderBashFinalResult(theme, raw, options, context);
+		return memoizedStateComponent(
+			context.state,
+			"__piStyleBashFinalResult",
+			getRenderCacheKey(
+				"bash-final-result",
+				theme,
+				Boolean(options.expanded),
+				Boolean(context.isError),
+				String(context?.args?.command ?? ""),
+				raw,
+				getStateElapsedMs(context.state) ?? "",
+			),
+			() => renderBashFinalResult(theme, raw, options, context),
+		);
 	},
 };