@fyeeme/pi-thinking-ui 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -1,6 +1,14 @@
 ## [Unreleased]
 
-### Added
+## [1.0.1] - 2025-07-25
+
+### Changed
+- Default thinking view mode is now `collapsed` instead of `summary`
+- Step-core cache: completed step summaries are memoized by step text, avoiding re-summarization of unchanged steps during streaming (linearizes per-derive summarization cost)
+- Inlined `blocksLengthFingerprint` at its single call site
+
+### Fixed
+- Respect the host `hideThinkingBlock` setting: when thinking is hidden, the extension falls back to Pi's native hidden-label renderer instead of forcing the custom thinking UI
 - Three-mode thinking visualization: `collapsed`, `summary`, `expanded`
 - Deterministic step derivation from raw thinking text
 - Semantic role inference with icons and colors

package/index.ts

@@ -63,7 +63,7 @@ async function restoreMode(ctx: ExtensionContext): Promise<ThinkingUIMode> {
 	if (projectMode) return projectMode;
 
 	const globalMode = await readRestoredModePreference(ctx, "global");
-	return globalMode ?? "summary";
+	return globalMode ?? "collapsed";
 }
 
 function refreshThinkingUI(ctx: ExtensionContext): void {

package/internal-patch.ts

@@ -271,6 +271,10 @@ async function installPatch(): Promise<() => void> {
 
 	const patchedUpdateContent = function patchedUpdateContent(this: AssistantMessageComponentPrototype, message: AssistantMessage): void {
 		this.lastMessage = message;
+		if (this.hideThinkingBlock) {
+			fallbackToOriginalUpdateContent(this, message, "updateContent");
+			return;
+		}
 		if (!hasPatchableContentContainer(this)) {
 			fallbackToOriginalUpdateContent(this, message, "updateContent");
 			return;
@@ -333,7 +337,7 @@ async function installPatch(): Promise<() => void> {
 			return;
 		}
 
-		this.hideThinkingBlock = false;
+		this.hideThinkingBlock = hide;
 		if (!this.lastMessage) return;
 		try {
 			this.updateContent(this.lastMessage);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fyeeme/pi-thinking-ui",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Faithful, terminal-native three-mode thinking visualization for Pi.",
   "type": "module",
   "license": "MIT",

package/parse.ts

@@ -1086,7 +1086,38 @@ export function iconForThinkingRole(role: ThinkingSemanticRole): string {
 	}
 }
 
-export function deriveThinkingUI(blocks: ThinkingSourceBlock[]): DerivedThinkingStep[] {
+export interface DerivedStepCore {
+	summary: string;
+	baselineSummary: string;
+	challengerSummary: string;
+	summaryEvents: ThinkingSummaryEvent[];
+	collapsedPriority: number;
+	hasExplicitFailure: boolean;
+	hasExplicitSuccess: boolean;
+	role: ThinkingSemanticRole;
+	icon: string;
+}
+
+export function deriveStepCore(stepText: string): DerivedStepCore {
+	const summaryDetails = summarizeThinkingTextDetailed(stepText);
+	const role = inferThinkingRole(`${summaryDetails.summary}\n${stepText}`);
+	return {
+		summary: summaryDetails.summary,
+		baselineSummary: summaryDetails.baselineSummary,
+		challengerSummary: summaryDetails.challengerSummary,
+		summaryEvents: summaryDetails.events,
+		collapsedPriority: summaryDetails.collapsedPriority,
+		hasExplicitFailure: summaryDetails.hasExplicitFailure,
+		hasExplicitSuccess: summaryDetails.hasExplicitSuccess,
+		role,
+		icon: iconForThinkingRole(role),
+	};
+}
+
+export function deriveThinkingUI(
+	blocks: ThinkingSourceBlock[],
+	resolveCore: (stepText: string) => DerivedStepCore = deriveStepCore,
+): DerivedThinkingStep[] {
 	const steps: DerivedThinkingStep[] = [];
 	blocks.forEach((block, blockIndex) => {
 		if (block.redacted && !block.text.trim()) {
@@ -1112,23 +1143,22 @@ export function deriveThinkingUI(blocks: ThinkingSourceBlock[]): DerivedThinking
 
 		const stepTexts = splitThinkingIntoStepTexts(block.text);
 		stepTexts.forEach((stepText, stepIndex) => {
-			const summaryDetails = summarizeThinkingTextDetailed(stepText);
-			const role = inferThinkingRole(`${summaryDetails.summary}\n${stepText}`);
+			const core = resolveCore(stepText);
 			steps.push({
 				id: `${block.contentIndex}-${stepIndex}`,
 				contentIndex: block.contentIndex,
 				blockIndex,
 				stepIndex,
-				summary: summaryDetails.summary,
+				summary: core.summary,
 				body: stepText.trim(),
-				role,
-				icon: iconForThinkingRole(role),
-				baselineSummary: summaryDetails.baselineSummary,
-				challengerSummary: summaryDetails.challengerSummary,
-				summaryEvents: summaryDetails.events,
-				collapsedPriority: summaryDetails.collapsedPriority,
-				hasExplicitFailure: summaryDetails.hasExplicitFailure,
-				hasExplicitSuccess: summaryDetails.hasExplicitSuccess,
+				role: core.role,
+				icon: core.icon,
+				baselineSummary: core.baselineSummary,
+				challengerSummary: core.challengerSummary,
+				summaryEvents: core.summaryEvents,
+				collapsedPriority: core.collapsedPriority,
+				hasExplicitFailure: core.hasExplicitFailure,
+				hasExplicitSuccess: core.hasExplicitSuccess,
 			});
 		});
 	});

package/render.ts

@@ -1,6 +1,7 @@
 import type { Component } from "@earendil-works/pi-tui";
 import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
-import { deriveThinkingUI } from "./parse.ts";
+import { deriveStepCore, deriveThinkingUI } from "./parse.ts";
+import type { DerivedStepCore } from "./parse.ts";
 import { getActiveThinkingState, getCurrentThinkingScopeKey, getThinkingUIMode } from "./state.ts";
 import type { DerivedThinkingStep, ThinkingSemanticRole, ThinkingSourceBlock, ThinkingThemeLike } from "./types.ts";
 
@@ -357,8 +358,81 @@ export function renderThinkingUILines(theme: ThinkingThemeLike, width: number, o
 	return renderSummary(theme, width, options.steps, options.activeStepId);
 }
 
+// Throttle: during active streaming, skip re-derivation unless the total
+// character change across blocks exceeds this threshold. This keeps the
+// spinner and input responsive during deep thinking while still updating
+// the summary at a visible cadence.
+const MIN_DELTA_CHARS_FOR_REDERIVE = 200;
+const THROTTLE_CACHE_LIMIT = 4;
+const throttleCache = new Map<number, { lengths: number[]; steps: DerivedThinkingStep[] }>();
+
+// Step-core cache: thinking text is append-only, so completed step texts are
+// byte-stable across re-derivations. Caching the expensive core (summary +
+// role) by step text avoids re-summarizing N-1 unchanged steps on each
+// throttle-miss derive, linearizing the per-derive summarization cost.
+const STEP_CORE_CACHE_LIMIT = 500;
+const stepCoreCache = new Map<string, DerivedStepCore>();
+
+function cachingCoreResolver(stepText: string): DerivedStepCore {
+	const cached = stepCoreCache.get(stepText);
+	if (cached) {
+		stepCoreCache.delete(stepText);
+		stepCoreCache.set(stepText, cached);
+		return cached;
+	}
+	const core = deriveStepCore(stepText);
+	if (stepCoreCache.size >= STEP_CORE_CACHE_LIMIT) {
+		const oldestKey = stepCoreCache.keys().next().value;
+		if (oldestKey !== undefined) {
+			stepCoreCache.delete(oldestKey);
+		}
+	}
+	stepCoreCache.set(stepText, core);
+	return core;
+}
+
+function totalLengthDelta(current: number[], previous: number[]): number {
+	let delta = 0;
+	for (let index = 0; index < Math.max(current.length, previous.length); index += 1) {
+		delta += Math.abs((current[index] ?? 0) - (previous[index] ?? 0));
+	}
+	return delta;
+}
+
+function deriveOrReuseSteps(
+	messageTimestamp: number,
+	scopeKey: string,
+	blocks: ThinkingSourceBlock[],
+): DerivedThinkingStep[] {
+	const active = getActiveThinkingState(messageTimestamp, scopeKey);
+	const lengths = blocks.map((block) => block.text.length);
+	const cached = throttleCache.get(messageTimestamp);
+
+	// During active streaming, skip re-derivation when only a few chars were appended.
+	if (active.active && cached) {
+		const delta = totalLengthDelta(lengths, cached.lengths);
+		if (delta < MIN_DELTA_CHARS_FOR_REDERIVE) {
+			return cached.steps;
+		}
+	}
+
+	const steps = deriveThinkingUI(blocks, cachingCoreResolver);
+
+	if (active.active) {
+		if (throttleCache.size >= THROTTLE_CACHE_LIMIT && !throttleCache.has(messageTimestamp)) {
+			const oldestKey = throttleCache.keys().next().value;
+			if (oldestKey !== undefined) {
+				throttleCache.delete(oldestKey);
+			}
+		}
+		throttleCache.set(messageTimestamp, { lengths, steps });
+	}
+
+	return steps;
+}
+
 export class ThinkingUIComponent implements Component {
-	private steps: DerivedThinkingStep[];
+	private readonly steps: DerivedThinkingStep[];
 	private cacheKey?: string;
 	private cachedLines?: string[];
 	private readonly scopeKey: string;
@@ -373,8 +447,8 @@ export class ThinkingUIComponent implements Component {
 	) {
 		this.theme = theme;
 		this.messageTimestamp = messageTimestamp;
-		this.steps = deriveThinkingUI(blocks);
 		this.scopeKey = scopeKey ?? getCurrentThinkingScopeKey();
+		this.steps = deriveOrReuseSteps(messageTimestamp, this.scopeKey, blocks);
 	}
 
 	render(width: number): string[] {

package/state.ts

@@ -54,7 +54,7 @@ function normalizeThinkingScopeKey(scopeKey?: string): string {
 }
 
 function normalizeThinkingMode(mode: unknown): ThinkingUIMode {
-	return mode === "collapsed" || mode === "summary" || mode === "expanded" ? mode : "summary";
+	return mode === "collapsed" || mode === "summary" || mode === "expanded" ? mode : "collapsed";
 }
 
 function normalizeActiveThinkingState(value: unknown): ActiveThinkingState {
@@ -167,7 +167,7 @@ const globalState = (() => {
 	}
 	const created: ThinkingUIGlobalState = {
 		currentScopeKey: DEFAULT_SCOPE_KEY,
-		modeByScopeKey: { [DEFAULT_SCOPE_KEY]: "summary" },
+		modeByScopeKey: { [DEFAULT_SCOPE_KEY]: "collapsed" },
 		activeByScopeKey: { [DEFAULT_SCOPE_KEY]: {} },
 		lastActiveByScopeKey: { [DEFAULT_SCOPE_KEY]: { active: false } },
 		refreshToggleByScope: {},
@@ -183,7 +183,7 @@ const globalState = (() => {
 
 function ensureScopeState(scopeKey: string): void {
 	if (!(scopeKey in globalState.modeByScopeKey)) {
-		globalState.modeByScopeKey[scopeKey] = "summary";
+		globalState.modeByScopeKey[scopeKey] = "collapsed";
 	}
 	if (!(scopeKey in globalState.activeByScopeKey)) {
 		globalState.activeByScopeKey[scopeKey] = {};
@@ -215,7 +215,7 @@ export function setCurrentThinkingScopeKey(scopeKey: string): void {
 export function getThinkingUIMode(scopeKey?: string): ThinkingUIMode {
 	const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey ?? globalState.currentScopeKey);
 	ensureScopeState(normalizedScopeKey);
-	return globalState.modeByScopeKey[normalizedScopeKey] ?? "summary";
+	return globalState.modeByScopeKey[normalizedScopeKey] ?? "collapsed";
 }
 
 export function setThinkingUIMode(mode: ThinkingUIMode, scopeKey?: string): void {
@@ -370,7 +370,7 @@ export function resetThinkingUIViewState(scopeKey?: string): void {
 	if (scopeKey !== undefined) {
 		const normalizedScopeKey = normalizeThinkingScopeKey(scopeKey);
 		globalState.currentScopeKey = normalizedScopeKey;
-		globalState.modeByScopeKey[normalizedScopeKey] = "summary";
+		globalState.modeByScopeKey[normalizedScopeKey] = "collapsed";
 		globalState.refreshToggleByScope[normalizedScopeKey] = false;
 		globalState.activeByScopeKey[normalizedScopeKey] = {};
 		globalState.lastActiveByScopeKey[normalizedScopeKey] = { active: false };
@@ -379,7 +379,7 @@ export function resetThinkingUIViewState(scopeKey?: string): void {
 	}
 
 	globalState.currentScopeKey = DEFAULT_SCOPE_KEY;
-	globalState.modeByScopeKey = { [DEFAULT_SCOPE_KEY]: "summary" };
+	globalState.modeByScopeKey = { [DEFAULT_SCOPE_KEY]: "collapsed" };
 	globalState.activeByScopeKey = { [DEFAULT_SCOPE_KEY]: {} };
 	globalState.lastActiveByScopeKey = { [DEFAULT_SCOPE_KEY]: { active: false } };
 	globalState.refreshToggleByScope = {};