@quandev104/pi-style 0.2.0 → 0.2.1

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

@@ -8,10 +8,10 @@
 // consume no vertical space.
 //
 // Design notes:
-// - No caching in the batch panel: it reads the module-level registry on every
-//   render, so member completions (which trigger ui.requestRender via Pi's
-//   tool_execution_end handler) are picked up without cross-component
-//   invalidation plumbing.
+// - Live batches render directly from the registry so member completions (which
+//   trigger ui.requestRender via Pi's tool_execution_end handler) are picked up
+//   without cross-component invalidation plumbing. Once a batch is finalized,
+//   width/config-stable renders reuse the cached line array.
 // - Batch boundaries: a new batch starts when the active batch is closed. The
 //   active batch closes when a non-batchable tool call is dispatched
 //   (boxed/index.ts), when a new message starts (pi/index.ts), and on session
@@ -31,7 +31,7 @@
 
 import type { Component } from "@earendil-works/pi-tui";
 import { stripAnsi } from "../../../shared/ansi.js";
-import { type BoxTheme, dimLine, formatToolTitlePrefix } from "../../../shared/box.js";
+import { type BoxTheme, dimLine, formatToolTitlePrefix, themeCacheKey } from "../../../shared/box.js";
 import { safeTruncateToWidth } from "../../../shared/render-budget.js";
 import {
 	fileIcon,
@@ -42,7 +42,7 @@ import {
 	TREE_CHILD_INDENT,
 	TREE_INDENT,
 } from "./output-tree.js";
-import { getToolsRenderConfig } from "./session-config.js";
+import { getToolsRenderCacheSignature, getToolsRenderConfig } from "./session-config.js";
 import type { BoxedToolContext } from "./shared.js";
 
 /** Quiet tools whose calls group into a single batch panel. */
@@ -78,6 +78,11 @@ export interface BatchMember {
 	outputEntries?: string[];
 }
 
+type BatchRenderCache = {
+	key: string;
+	lines: string[];
+};
+
 export interface BatchState {
 	readonly meta: BatchToolMeta;
 	readonly leaderId: string;
@@ -85,6 +90,8 @@ export interface BatchState {
 	completedAt?: number;
 	closed: boolean;
 	readonly members: BatchMember[];
+	revision: number;
+	renderCache?: BatchRenderCache;
 }
 
 /** Tree head limit: only the first few members are listed, the rest collapse. */
@@ -130,6 +137,7 @@ function createBatch(
 		leaderId,
 		startedAt: performance.now(),
 		closed: false,
+		revision: 0,
 		members: [
 			{
 				toolCallId: leaderId,
@@ -146,6 +154,11 @@ function createBatch(
 	return batch;
 }
 
+function bumpBatchRevision(batch: BatchState): void {
+	batch.revision++;
+	delete batch.renderCache;
+}
+
 /**
  * Register a call renderer invocation. Idempotent per toolCallId: re-fires
  * (updateDisplay on the same component) reuse the call's existing batch, even
@@ -161,9 +174,12 @@ export function registerBatchCall(
 	if (existing) {
 		const member = existing.members.find((entry) => entry.toolCallId === context.toolCallId);
 		if (member) {
+			const changed =
+				member.detail !== detail || member.pattern !== opts.pattern || member.pathLabel !== opts.pathLabel;
 			member.detail = detail;
 			if (opts.pattern !== undefined) member.pattern = opts.pattern;
 			if (opts.pathLabel !== undefined) member.pathLabel = opts.pathLabel;
+			if (changed) bumpBatchRevision(existing);
 		}
 		return { batch: existing, isLeader: existing.leaderId === context.toolCallId };
 	}
@@ -182,6 +198,7 @@ export function registerBatchCall(
 	};
 	current.members.push(member);
 	batchByCallId.set(context.toolCallId, current);
+	bumpBatchRevision(current);
 	return { batch: current, isLeader: false };
 }
 
@@ -208,14 +225,23 @@ export function registerBatchResult(
 	if (!batch || batch.meta.toolName !== meta.toolName) return { batch: undefined, isLeader: false };
 	const member = batch.members.find((entry) => entry.toolCallId === context.toolCallId);
 	if (member) {
-		member.status = data.isPartial ? "running" : "done";
-		member.isError = !data.isPartial && data.isError;
+		const nextStatus = data.isPartial ? "running" : "done";
+		const nextIsError = !data.isPartial && data.isError;
+		const changed =
+			member.status !== nextStatus ||
+			member.isError !== nextIsError ||
+			member.errorText !== (nextIsError ? data.errorText : undefined) ||
+			member.outputEntries !== data.entries;
+		member.status = nextStatus;
+		member.isError = nextIsError;
 		if (member.isError && data.errorText !== undefined) member.errorText = data.errorText;
 		else delete member.errorText;
 		if (data.entries !== undefined) member.outputEntries = data.entries;
+		if (changed) bumpBatchRevision(batch);
 	}
 	if (batch.completedAt === undefined && batch.members.every((entry) => entry.status === "done")) {
 		batch.completedAt = performance.now();
+		bumpBatchRevision(batch);
 	}
 	return { batch, isLeader: batch.leaderId === context.toolCallId };
 }
@@ -459,9 +485,17 @@ function renderBatchPanelLines(theme: BoxTheme, batch: BatchState, status: Batch
  */
 export function renderBatchAwareCall(theme: BoxTheme, batch: BatchState): Component {
 	return {
-		invalidate() {},
+		invalidate() {
+			delete batch.renderCache;
+		},
 		render(width: number): string[] {
-			return renderBatchPanelLines(theme, batch, batchStatus(batch), width);
+			const status = batchStatus(batch);
+			if (!status.allDone) return renderBatchPanelLines(theme, batch, status, width);
+			const cacheKey = [themeCacheKey(theme), getToolsRenderCacheSignature(), width, batch.revision].join("|");
+			if (batch.renderCache?.key === cacheKey) return batch.renderCache.lines;
+			const lines = renderBatchPanelLines(theme, batch, status, width);
+			batch.renderCache = { key: cacheKey, lines };
+			return lines;
 		},
 	};
 }

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

@@ -24,6 +24,8 @@ import {
 	type BoxedToolContext,
 	type BoxedToolDefinition,
 	displayPath,
+	getRenderCacheKey,
+	memoizedStateComponent,
 	noteBoxedCallState,
 	noteBoxedResultPhase,
 	noteExecutionStart,
@@ -133,21 +135,34 @@ export const editTool: BoxedToolDefinition = {
 		const diffView = new AdaptiveDiffComponent(theme, rows, maxRows, shouldHighlight ? language : undefined);
 		const expandHint = !expanded && diffView.hasCollapsed() ? "Ctrl+O more" : undefined;
 
-		return renderBoxedToolResult(
-			theme,
-			{
-				render(width: number): string[] {
-					return diffView.render(width);
-				},
-				invalidate(): void {
-					diffView.invalidate();
-				},
-			},
-			{
-				dividerLabel: diffDividerLabel(theme, stats),
-				...(expandHint ? { dividerRightLabel: expandHint } : {}),
-				footerLines: [editDiffFooter(theme, result, context, stats)],
-			},
+		return memoizedStateComponent(
+			context.state,
+			"__piStyleEditDiffResult",
+			getRenderCacheKey(
+				"edit-diff-result",
+				theme,
+				Boolean(expanded),
+				diff,
+				sourcePath ?? "",
+				editDiffFooter(theme, result, context, stats),
+			),
+			() =>
+				renderBoxedToolResult(
+					theme,
+					{
+						render(width: number): string[] {
+							return diffView.render(width);
+						},
+						invalidate(): void {
+							diffView.invalidate();
+						},
+					},
+					{
+						dividerLabel: diffDividerLabel(theme, stats),
+						...(expandHint ? { dividerRightLabel: expandHint } : {}),
+						footerLines: [editDiffFooter(theme, result, context, stats)],
+					},
+				),
 		);
 	},
 };

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

@@ -16,6 +16,8 @@ import {
 	type BoxedToolContext,
 	type BoxedToolDefinition,
 	displayPath,
+	getRenderCacheKey,
+	memoizedStateComponent,
 	noteBoxedCallState,
 	noteBoxedResultPhase,
 	noteExecutionStart,
@@ -184,21 +186,35 @@ function renderQuickEditResult(
 	const diffView = new AdaptiveDiffComponent(theme, rows, maxRows, shouldHighlight ? language : undefined);
 	const expandHint = !expanded && diffView.hasCollapsed() ? "Ctrl+O more" : undefined;
 
-	return renderBoxedToolResult(
-		theme,
-		{
-			render(width: number): string[] {
-				return diffView.render(width);
-			},
-			invalidate(): void {
-				diffView.invalidate();
-			},
-		},
-		{
-			dividerLabel: quickEditDividerLabel(theme, stats),
-			...(expandHint ? { dividerRightLabel: expandHint } : {}),
-			footerLines: [quickEditDiffFooter(theme, result, context, stats)],
-		},
+	return memoizedStateComponent(
+		context.state,
+		"__piStyleQuickEditDiffResult",
+		getRenderCacheKey(
+			"quick-edit-diff-result",
+			theme,
+			config.toolLabel,
+			Boolean(expanded),
+			diff,
+			argPath,
+			quickEditDiffFooter(theme, result, context, stats),
+		),
+		() =>
+			renderBoxedToolResult(
+				theme,
+				{
+					render(width: number): string[] {
+						return diffView.render(width);
+					},
+					invalidate(): void {
+						diffView.invalidate();
+					},
+				},
+				{
+					dividerLabel: quickEditDividerLabel(theme, stats),
+					...(expandHint ? { dividerRightLabel: expandHint } : {}),
+					footerLines: [quickEditDiffFooter(theme, result, context, stats)],
+				},
+			),
 	);
 }
 

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

@@ -37,6 +37,19 @@ export function getToolsRenderConfig(): ToolsRenderConfig {
 	return sessionToolsConfig;
 }
 
+export function getToolsRenderCacheSignature(): string {
+	return [
+		sessionToolsConfig.maxCollapsedLines,
+		sessionToolsConfig.maxExpandedLines,
+		sessionToolsConfig.dimOutput ? 1 : 0,
+		sessionToolsConfig.showElapsed ? 1 : 0,
+		sessionToolsConfig.batchOpenGlyph,
+		sessionToolsConfig.nerdFonts ? 1 : 0,
+		sessionToolsConfig.collapseAfterTurn ? 1 : 0,
+		sessionToolsConfig.collapseMutatingTools ? 1 : 0,
+	].join("|");
+}
+
 // Wall-clock elapsed tracking through the renderer context state (no tool
 // re-registration, so result.details has no execution timing).
 //
@@ -83,8 +96,26 @@ export function markResultSeen(state: Record<string, unknown> | undefined): void
 
 type TickerHandle = ReturnType<typeof setInterval>;
 
-/** States that currently own a 1s elapsed-render interval, for session cleanup. */
-const tickerStates = new Set<Record<string, unknown>>();
+type ElapsedTickerEntry = {
+	invalidate: () => void;
+};
+
+/** States currently subscribed to the shared elapsed-render ticker. */
+const tickerEntries = new Map<Record<string, unknown>, ElapsedTickerEntry>();
+let sharedTickerHandle: TickerHandle | undefined;
+
+function ensureSharedTicker(): void {
+	if (sharedTickerHandle !== undefined || tickerEntries.size === 0) return;
+	sharedTickerHandle = setInterval(() => {
+		for (const { invalidate } of tickerEntries.values()) invalidate();
+	}, 1000) as unknown as TickerHandle;
+}
+
+function stopSharedTickerIfIdle(): void {
+	if (sharedTickerHandle === undefined || tickerEntries.size > 0) return;
+	clearInterval(sharedTickerHandle);
+	sharedTickerHandle = undefined;
+}
 
 /**
  * While a tool is running, re-render once per second so live elapsed labels
@@ -92,26 +123,26 @@ const tickerStates = new Set<Record<string, unknown>>();
  */
 export function startElapsedTicker(state: Record<string, unknown> | undefined, invalidate: () => void): void {
 	if (!state || typeof state !== "object") return;
-	if (state[TICKER_KEY] !== undefined) return;
-	state[TICKER_KEY] = setInterval(() => invalidate(), 1000) as unknown as TickerHandle;
-	tickerStates.add(state);
+	state[TICKER_KEY] = true;
+	tickerEntries.set(state, { invalidate });
+	ensureSharedTicker();
 }
 
 /** Stop a running tool's elapsed ticker (terminal result, error, session end). */
 export function stopElapsedTicker(state: Record<string, unknown> | undefined): void {
 	if (!state || typeof state !== "object") return;
-	const handle = state[TICKER_KEY] as TickerHandle | undefined;
-	if (handle !== undefined) clearInterval(handle);
 	delete state[TICKER_KEY];
-	tickerStates.delete(state);
+	tickerEntries.delete(state);
+	stopSharedTickerIfIdle();
 }
 
 /** Stop every elapsed ticker (session start/shutdown). */
 export function stopAllElapsedTickers(): void {
-	for (const state of tickerStates) {
-		const handle = state[TICKER_KEY] as TickerHandle | undefined;
-		if (handle !== undefined) clearInterval(handle);
-		delete state[TICKER_KEY];
-	}
-	tickerStates.clear();
+	for (const state of tickerEntries.keys()) delete state[TICKER_KEY];
+	tickerEntries.clear();
+	stopSharedTickerIfIdle();
+}
+
+export function __getElapsedTickerDebugState(): { trackedStates: number; hasSharedTicker: boolean } {
+	return { trackedStates: tickerEntries.size, hasSharedTicker: sharedTickerHandle !== undefined };
 }

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

@@ -12,9 +12,11 @@ import {
 	renderCompactBoxedToolCall,
 	resolveRelativePath,
 	shortenPath,
+	themeCacheKey,
 } from "../../../shared/box.js";
 import {
 	getStateElapsedMs,
+	getToolsRenderCacheSignature,
 	isResultSeen,
 	markResultSeen,
 	recordExecutionEnded,
@@ -174,6 +176,29 @@ export function resultFooterLines(
 	return [formatBoxedFooter(theme, result, extraParts, stateElapsedMs(context))];
 }
 
+type StateComponentCacheEntry = {
+	key: string;
+	component: Component;
+};
+
+export function getRenderCacheKey(prefix: string, theme: BoxTheme, ...parts: Array<string | number | boolean>): string {
+	return [prefix, themeCacheKey(theme), getToolsRenderCacheSignature(), ...parts].join("|");
+}
+
+export function memoizedStateComponent(
+	state: Record<string, unknown> | undefined,
+	slot: string,
+	key: string,
+	build: () => Component,
+): Component {
+	if (!state || typeof state !== "object") return build();
+	const cached = state[slot] as StateComponentCacheEntry | undefined;
+	if (cached && cached.key === key) return cached.component;
+	const component = build();
+	state[slot] = { key, component } satisfies StateComponentCacheEntry;
+	return component;
+}
+
 export function clearFooterState(context: BoxedToolContext): void {
 	clearCompactBoxedFooter(context.state);
 }

package/extension-src/pi-style/pi/compatibility-probe.ts

@@ -145,7 +145,7 @@ export const KNOWN_NATIVE_IDENTITIES: Readonly<Record<string, readonly KnownNati
 /** Primary (first-recorded) fingerprint per surface, for diagnostics and back-compat. */
 export const TRUSTED_NATIVE_FINGERPRINTS: Readonly<Record<string, string>> = Object.freeze(
 	Object.fromEntries(
-		Object.entries(KNOWN_NATIVE_IDENTITIES).map(([key, identities]) => [key, identities[0]!.fingerprint]),
+		Object.entries(KNOWN_NATIVE_IDENTITIES).map(([key, identities]) => [key, identities[0]?.fingerprint ?? ""]),
 	),
 );
 

package/extension-src/pi-style/pi/index.ts

@@ -11,12 +11,11 @@ import {
 import { requestToolPresentationRender } from "../features/tools/index.js";
 import { registerPiStyleCommand } from "./commands.js";
 import { type CompatibilityTestHooks, createPiStyleSessionCoordinator } from "./session-coordinator.js";
-import { usageFromSession } from "./session-usage.js";
+import { resetUsageFromSessionCache, usageFromSession } from "./session-usage.js";
 
-/** Usage patch that omits the key when no session usage exists (exact optional types). */
+/** Usage patch clears stale usage when the active branch/session has none. */
 function usagePatch(ctx: ExtensionContext): StatusSnapshot {
-	const usage = usageFromSession(ctx.sessionManager);
-	return usage ? { usage } : {};
+	return { usage: usageFromSession(ctx.sessionManager) } as StatusSnapshot;
 }
 
 /**
@@ -65,6 +64,7 @@ export default function piStyleExtension(pi: ExtensionAPI): void {
 	const coordinator = createPiStyleSessionCoordinator(pi, compatibilityTestHooks);
 	registerPiStyleCommand(pi, coordinator.app);
 	pi.on("session_start", async (event, ctx) => {
+		resetUsageFromSessionCache(ctx.sessionManager);
 		// Pi only activates read/bash/edit/write by default; grep/find/ls are
 		// registered but inactive (kept out of the model's tool list to keep the
 		// core small). Activate them so the TUI shows them and the model can call
@@ -110,7 +110,9 @@ export default function piStyleExtension(pi: ExtensionAPI): void {
 		),
 	);
 	pi.on("thinking_level_select", (event) => coordinator.app.update({ thinkingLevel: event.level }, "immediate"));
-	pi.on("session_info_changed", (event) => coordinator.app.update({ sessionName: event.name }, "coalesced"));
+	pi.on("session_info_changed", (event) =>
+		coordinator.app.update({ sessionName: event.name }, "coalesced", { refreshExtensionStatuses: true }),
+	);
 	pi.on("message_start", () => {
 		// A new message is a batch boundary: quiet-tool (read/ls/find) calls of the
 		// new message start a fresh batch instead of joining the previous one.
@@ -123,11 +125,13 @@ export default function piStyleExtension(pi: ExtensionAPI): void {
 	// Usage (tokens + cost) is aggregated from finalized session entries at
 	// message/turn boundaries, mirroring Pi's native footer; per-chunk updates
 	// stay usage-free to keep streaming cheap.
-	pi.on("message_end", (_event, ctx) => coordinator.app.update({ ...usagePatch(ctx) }, "coalesced"));
+	pi.on("message_end", (_event, ctx) =>
+		coordinator.app.update({ ...usagePatch(ctx) }, "coalesced", { refreshContextUsage: true }),
+	);
 	pi.on("turn_end", (event, ctx) => {
 		// Append the finalized assistant message's tool batch to the current run.
 		registerTurnFromMessage(event.message, event.toolResults);
-		coordinator.app.update({ ...usagePatch(ctx) }, "deferred");
+		coordinator.app.update({ ...usagePatch(ctx) }, "deferred", { refreshContextUsage: true });
 	});
 	pi.on("agent_end", () => {
 		// The run is complete: collapse its tool blocks into one summary line.
@@ -141,23 +145,32 @@ export default function piStyleExtension(pi: ExtensionAPI): void {
 			requestToolPresentationRender();
 		}
 	});
-	pi.on("agent_settled", (_event, ctx) => coordinator.app.update({ ...usagePatch(ctx) }, "coalesced"));
+	pi.on("agent_settled", (_event, ctx) =>
+		coordinator.app.update({ ...usagePatch(ctx) }, "coalesced", { refreshContextUsage: true }),
+	);
 	pi.on("session_tree", (_event, ctx) => {
+		resetUsageFromSessionCache(ctx.sessionManager);
 		// Rebuild the turn registry from session content so restored/branched
 		// history renders collapsed consistently (no in-process turn_end events).
 		rebuildTurnRegistryFromEntries(ctx.sessionManager.getEntries());
-		coordinator.app.update({ ...usagePatch(ctx) }, "deferred");
+		coordinator.app.update({ ...usagePatch(ctx) }, "deferred", { refreshContextUsage: true });
+	});
+	pi.on("session_compact", (_event, ctx) => {
+		resetUsageFromSessionCache(ctx.sessionManager);
+		coordinator.app.update({ ...usagePatch(ctx) }, "deferred", { refreshContextUsage: true });
 	});
-	pi.on("session_compact", (_event, ctx) => coordinator.app.update({ ...usagePatch(ctx) }, "deferred"));
 	pi.on("tool_result", (event, ctx) => {
 		if (["write", "edit", "bash"].includes(event.toolName)) {
 			coordinator.app.runtime.current?.invalidateGit();
-			coordinator.app.update({ ...usagePatch(ctx) }, "delayed-retry");
+			coordinator.app.update({ ...usagePatch(ctx) }, "delayed-retry", { refreshContextUsage: true });
 		}
 	});
 	pi.on("user_bash", (_event, ctx) => {
 		coordinator.app.runtime.current?.invalidateGit();
-		coordinator.app.update({ ...usagePatch(ctx) }, "delayed-retry");
+		coordinator.app.update({ ...usagePatch(ctx) }, "delayed-retry", { refreshContextUsage: true });
+	});
+	pi.on("session_shutdown", (_event, ctx) => {
+		resetUsageFromSessionCache(ctx.sessionManager);
+		coordinator.shutdown();
 	});
-	pi.on("session_shutdown", () => coordinator.shutdown());
 }