@fyeeme/pi-thinking-ui 1.0.1 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [1.1.0] - 2026-08-08
+
+### Removed
+
+- Internal monkeypatch of pi compiled modules (`internal-patch.ts`, `render.ts`) — thinking rendering no longer imports `dist/modes/interactive/...` internals; it now uses the provided `registerMarkdownTransformer` hook only.
+
+### Changed
+
+- Thinking rendering rebuilt on `registerMarkdownTransformer` (new `markdown-render.ts`): `collapsed` → one blockquote line (role icon + summary), `summary` → bullet list of derived step summaries (capped, `… (+N more)` tail), `expanded` → passthrough. Reuses the pure-heuristic `parse.ts` engine.
+- Streaming: the full heuristic derivation now runs only on finalize/restore/resize; during streaming a cheap first-line view is shown for `collapsed` (pi's transformer contract requires synchronous, inexpensive transformers).
+- `state.ts` slimmed: removed patch bookkeeping and the now-unused active-thinking-state / message-scope-ownership subsystems.
+- Mode switching re-renders via the existing `refreshThinkingUI` (`setHiddenThinkingLabel` toggle); mode resolution for rendering is process-global (transformer context carries no message/scope identity).
+
 ## [1.0.1] - 2025-07-25
 
 ### Changed

package/index.ts

@@ -1,10 +1,15 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { AutocompleteItem } from "@earendil-works/pi-tui";
 import { Key } from "@earendil-works/pi-tui";
-import { retainThinkingUIPatch } from "./internal-patch.ts";
 import { clearThinkingUIModePreference, readThinkingUIModePreference, writeThinkingUIModePreference } from "./persistence.ts";
 import { parseThinkingMode } from "./parse.ts";
-import { clearActiveThinkingState, clearThinkingMessageOwnership, getCurrentThinkingScopeKey, getThinkingUIMode, nextThinkingRefreshLabel, recordThinkingMessageScope, registerThinkingPatchRelease, resolveThinkingMessageScope, setActiveThinkingState, setCurrentThinkingScopeKey, setThinkingUIMode, takeThinkingPatchRelease } from "./state.ts";
+import { streamingThinkingMarkdown, thinkingToMarkdown } from "./markdown-render.ts";
+import {
+	getThinkingUIMode,
+	nextThinkingRefreshLabel,
+	setCurrentThinkingScopeKey,
+	setThinkingUIMode,
+} from "./state.ts";
 import type { PersistedThinkingUIPreferenceScope, ThinkingUIMode } from "./types.ts";
 
 type ThinkingUICommandScope = "session" | PersistedThinkingUIPreferenceScope;
@@ -66,6 +71,14 @@ async function restoreMode(ctx: ExtensionContext): Promise<ThinkingUIMode> {
 	return globalMode ?? "collapsed";
 }
 
+/**
+ * Force every AssistantMessageComponent to re-run updateContent (and thus the
+ * markdown transformer) by toggling the hidden-thinking label through pi's
+ * ctx.ui proxy. `nextThinkingRefreshLabel` appends/toggles an invisible suffix
+ * so the label string changes on every call — without it, setHiddenThinkingLabel
+ * would no-op when the visible label is unchanged and the new mode would not
+ * take effect until the next natural re-render.
+ */
 function refreshThinkingUI(ctx: ExtensionContext): void {
 	if (!ctx.hasUI) return;
 	setCurrentThinkingScopeKey(ctx.cwd);
@@ -175,28 +188,25 @@ function reportPersistenceError(ctx: ExtensionContext, error: unknown): void {
 	notifyUser(ctx, `Thinking UI persistence error: ${error instanceof Error ? error.message : String(error)}`, "warning");
 }
 
-function reportPatchError(ctx: ExtensionContext, error: unknown): void {
-	notifyUser(ctx, `Thinking UI patch error: ${error instanceof Error ? error.message : String(error)}`, "warning");
-}
-
 export default function thinkingUIExtension(pi: ExtensionAPI): void {
-	let sessionScopeKey = getCurrentThinkingScopeKey();
-	const degradedSessionScopes = new Set<string>();
-	const setSessionScopeKey = (scopeKey: string): string => {
-		sessionScopeKey = scopeKey;
-		setCurrentThinkingScopeKey(scopeKey);
-		return sessionScopeKey;
-	};
-	const markSessionDegraded = (scopeKey: string, degraded: boolean): void => {
-		if (degraded) {
-			degradedSessionScopes.add(scopeKey);
-			return;
-		}
-		degradedSessionScopes.delete(scopeKey);
-	};
-	const isSessionDegraded = (scopeKey: string): boolean => degradedSessionScopes.has(scopeKey);
-	const degradedSessionMessage = (): string => "Thinking UI is using Pi's native thinking renderer for this session; live mode switching is disabled.";
-	const futureCompatibleSessionMessage = (scope: PersistedThinkingUIPreferenceScope, action: "saved" | "cleared"): string => `${action === "saved" ? "Saved" : "Cleared"} ${scope} thinking view default for future compatible sessions; the current session is using Pi's native thinking renderer.`;
+	// Render thinking via the provided markdown-transformer hook (no monkeypatch).
+	// The native Markdown renderer draws whatever we return, styled as thinking
+	// text. Re-runs on streaming, finalize, restore, resize, and whenever
+	// refreshThinkingUI toggles the hidden-thinking label (mode switch).
+	//
+	// Scope caveat: MarkdownTransformContext carries no message/scope identity, so
+	// the transformer resolves mode from the process-global currentScopeKey. The
+	// per-scope mode map still serves the command/shortcut handlers (which have
+	// ctx.cwd); only rendering is process-global. Fine while pi is single-session
+	// interactive; a host-side scope id would be needed to fix (out of scope here).
+	pi.registerMarkdownTransformer((markdown, context) => {
+		if (context.messageType !== "assistant-thinking") return markdown;
+		const mode = getThinkingUIMode();
+		// Heavy heuristic derivation only on finalize/restore/resize; during
+		// streaming (every chunk) stay cheap per pi's transformer contract.
+		if (context.isStreaming) return streamingThinkingMarkdown(markdown, mode);
+		return thinkingToMarkdown(markdown, mode);
+	});
 
 	pi.registerCommand("thinking-ui", {
 		description: "Switch thinking view or set/clear project/global defaults",
@@ -208,7 +218,6 @@ export default function thinkingUIExtension(pi: ExtensionAPI): void {
 				return;
 			}
 
-			const degraded = isSessionDegraded(ctx.cwd);
 			if (action.type === "clear") {
 				try {
 					await clearThinkingUIModePreference(action.scope, ctx.cwd);
@@ -217,11 +226,6 @@ export default function thinkingUIExtension(pi: ExtensionAPI): void {
 					return;
 				}
 
-				if (degraded) {
-					notifyUser(ctx, futureCompatibleSessionMessage(action.scope, "cleared"), "info");
-					return;
-				}
-
 				refreshThinkingUI(ctx);
 				notifyUser(ctx, `Cleared ${action.scope} thinking view default`, "info");
 				return;
@@ -241,15 +245,6 @@ export default function thinkingUIExtension(pi: ExtensionAPI): void {
 				}
 			}
 
-			if (degraded) {
-				if (action.scope === "session") {
-					notifyUser(ctx, degradedSessionMessage(), "warning");
-					return;
-				}
-				notifyUser(ctx, futureCompatibleSessionMessage(action.scope, "saved"), "info");
-				return;
-			}
-
 			applyMode(pi, ctx, selectedMode, { announceScope: action.scope });
 		},
 	});
@@ -257,104 +252,21 @@ export default function thinkingUIExtension(pi: ExtensionAPI): void {
 	pi.registerShortcut(Key.alt("t"), {
 		description: "Cycle thinking view (collapsed, summary, expanded)",
 		handler: async (ctx) => {
-			if (isSessionDegraded(ctx.cwd)) {
-				notifyUser(ctx, degradedSessionMessage(), "warning");
-				return;
-			}
 			const nextMode = cycleMode(getThinkingUIMode(ctx.cwd));
 			applyMode(pi, ctx, nextMode, { announceScope: "session" });
 		},
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
-		const activeScopeKey = setSessionScopeKey(ctx.cwd);
-		clearActiveThinkingState(undefined, activeScopeKey);
-		try {
-			registerThinkingPatchRelease(activeScopeKey, await retainThinkingUIPatch());
-			markSessionDegraded(activeScopeKey, false);
-		} catch (error) {
-			markSessionDegraded(activeScopeKey, true);
-			reportPatchError(ctx, error);
-			notifyUser(ctx, degradedSessionMessage(), "warning");
-			return;
-		}
-
+		setCurrentThinkingScopeKey(ctx.cwd);
 		const restoredMode = await restoreMode(ctx);
 		applyMode(pi, ctx, restoredMode, { persistSession: false });
 	});
 
-	pi.on("message_start", async (event) => {
-		if (event.message.role === "assistant") {
-			recordThinkingMessageScope(event.message, sessionScopeKey);
-			const ownerScopeKey = resolveThinkingMessageScope(event.message, sessionScopeKey);
-			const timestamp = typeof (event.message as { timestamp?: unknown }).timestamp === "number"
-				? (event.message as { timestamp: number }).timestamp
-				: undefined;
-			clearActiveThinkingState(timestamp, ownerScopeKey);
-		}
-	});
-
-	pi.on("message_update", async (event) => {
-		if (event.message.role !== "assistant") return;
-		recordThinkingMessageScope(event.message, sessionScopeKey);
-		const ownerScopeKey = resolveThinkingMessageScope(event.message, sessionScopeKey);
-		const assistantEvent = event.assistantMessageEvent;
-		if (assistantEvent.type === "thinking_start" || assistantEvent.type === "thinking_delta") {
-			setActiveThinkingState({
-				active: true,
-				messageTimestamp: event.message.timestamp,
-				contentIndex: assistantEvent.contentIndex,
-			}, ownerScopeKey);
-			return;
-		}
-
-		if (
-			assistantEvent.type === "thinking_end" ||
-			assistantEvent.type === "text_start" ||
-			assistantEvent.type === "text_delta" ||
-			assistantEvent.type === "text_end" ||
-			assistantEvent.type === "toolcall_start" ||
-			assistantEvent.type === "toolcall_delta" ||
-			assistantEvent.type === "toolcall_end"
-		) {
-			clearActiveThinkingState(event.message.timestamp, ownerScopeKey);
-		}
-	});
-
-	pi.on("message_end", async (event) => {
-		if (event.message.role === "assistant") {
-			recordThinkingMessageScope(event.message, sessionScopeKey);
-			const ownerScopeKey = resolveThinkingMessageScope(event.message, sessionScopeKey);
-			const timestamp = typeof (event.message as { timestamp?: unknown }).timestamp === "number"
-				? (event.message as { timestamp: number }).timestamp
-				: undefined;
-			clearActiveThinkingState(timestamp, ownerScopeKey);
-		}
-	});
-
-	pi.on("agent_end", async () => {
-		clearActiveThinkingState(undefined, sessionScopeKey);
-	});
-
 	pi.on("session_shutdown", async (_event, ctx) => {
-		const activeScopeKey = setSessionScopeKey(ctx.cwd);
-		clearActiveThinkingState(undefined, activeScopeKey);
-		clearThinkingMessageOwnership(activeScopeKey);
-		markSessionDegraded(activeScopeKey, false);
+		setCurrentThinkingScopeKey(ctx.cwd);
 		if (ctx.hasUI) {
 			ctx.ui.setStatus("thinking-ui", undefined);
 		}
-
-		const releasePatch = takeThinkingPatchRelease(activeScopeKey);
-		if (!releasePatch) {
-			return;
-		}
-
-		try {
-			await releasePatch();
-		} catch (error) {
-			registerThinkingPatchRelease(activeScopeKey, releasePatch);
-			reportPatchError(ctx, error);
-		}
 	});
 }

package/markdown-render.ts

@@ -0,0 +1,104 @@
+/**
+ * thinking-ui markdown emitter.
+ *
+ * Converts raw thinking text into the markdown string the registered
+ * transformer returns, per the current ThinkingUIMode. Reuses the pure
+ * heuristic engine in parse.ts (summarize / split / role) — no LLM, no async.
+ *
+ * Trade-off vs the removed ThinkingUIComponent (ANSI tree): the native
+ * Markdown renderer draws whatever markdown we return, styled as thinking
+ * text (dim/italic). The bespoke connector tree (├─└─) and live activity
+ * pulse are gone; the summary text + per-step role icons survive.
+ */
+import type { ThinkingUIMode } from "./types.ts";
+import { deriveStepCore, splitThinkingIntoStepTexts } from "./parse.ts";
+
+/** Cap the summary-mode list so a long thinking run stays readable. */
+const SUMMARY_LIST_LIMIT = 8;
+/** Max chars of the first line shown for collapsed mode while streaming. */
+const STREAMING_LINE_MAX = 80;
+
+/**
+ * LRU result cache for the finalize-path derivation. The transformer re-runs
+ * on every re-render where the cached width changed (e.g. terminal resize) —
+ * the thinking text is unchanged, so the result is fully reusable. Keyed by
+ * (mode, text) since thinkingToMarkdown output does not depend on width.
+ * Bounded to keep memory in check (each key holds a copy of the thinking text).
+ */
+const RESULT_CACHE_LIMIT = 50;
+const resultCache = new Map<string, string>();
+
+/** One blockquote line: role icon + summary. Derived via the fused parse.ts core. */
+function collapseLine(text: string): string {
+	const core = deriveStepCore(text);
+	return `> ${core.icon} ${core.summary}`;
+}
+
+/**
+ * Cheap view while the assistant message is still streaming, before the full
+ * heuristic derivation runs on finalize. collapsed → first line (keeps the
+ * "hide the bulk" intent without the O(n²) MMR cost); summary/expanded → pass
+ * through so the user can read the live stream. The transformer must stay
+ * "synchronous and inexpensive" (pi docs) and runs on every streaming chunk.
+ */
+export function streamingThinkingMarkdown(markdown: string, mode: ThinkingUIMode): string {
+	if (mode !== "collapsed") return markdown;
+	const line = markdown.split("\n").map((l) => l.trim()).find(Boolean);
+	if (!line) return markdown;
+	return `> ${line.length > STREAMING_LINE_MAX ? `${line.slice(0, STREAMING_LINE_MAX - 1)}…` : line}`;
+}
+
+/**
+ * Transform a run of thinking markdown for the given mode (finalize/restore).
+ *
+ * - expanded: pass through verbatim (native renderer handles full text).
+ * - collapsed: one blockquote line — role icon + the single best summary.
+ * - summary: a markdown bullet list of derived step summaries (icon + summary),
+ *   capped at SUMMARY_LIST_LIMIT with a `… (+N more)` tail.
+ *
+ * Result is memoized per (mode, text) — the expensive MMR derivation is not
+ * re-run for unchanged text across re-renders (resize, restore, …).
+ */
+export function thinkingToMarkdown(markdown: string, mode: ThinkingUIMode): string {
+	const cacheKey = `${mode}\u0000${markdown}`;
+	const cached = resultCache.get(cacheKey);
+	if (cached !== undefined) {
+		// LRU refresh: move to the newest slot.
+		resultCache.delete(cacheKey);
+		resultCache.set(cacheKey, cached);
+		return cached;
+	}
+
+	const result = computeThinkingToMarkdown(markdown, mode);
+
+	resultCache.set(cacheKey, result);
+	if (resultCache.size > RESULT_CACHE_LIMIT) {
+		const oldestKey = resultCache.keys().next().value;
+		if (oldestKey !== undefined) {
+			resultCache.delete(oldestKey);
+		}
+	}
+	return result;
+}
+
+function computeThinkingToMarkdown(markdown: string, mode: ThinkingUIMode): string {
+	if (mode === "expanded") return markdown;
+
+	const text = markdown.trim();
+	if (!text) return markdown;
+
+	if (mode === "collapsed") return collapseLine(text);
+
+	const steps = splitThinkingIntoStepTexts(text);
+	if (steps.length === 0) return collapseLine(text);
+
+	const visible = steps.slice(0, SUMMARY_LIST_LIMIT);
+	const lines = visible.map((step) => {
+		const core = deriveStepCore(step);
+		return `- ${core.icon} ${core.summary}`;
+	});
+	if (steps.length > visible.length) {
+		lines.push(`- … (+${steps.length - visible.length} more)`);
+	}
+	return lines.join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fyeeme/pi-thinking-ui",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Faithful, terminal-native three-mode thinking visualization for Pi.",
   "type": "module",
   "license": "MIT",
@@ -28,10 +28,9 @@
   ],
   "files": [
     "index.ts",
-    "internal-patch.ts",
+    "markdown-render.ts",
     "parse.ts",
     "persistence.ts",
-    "render.ts",
     "state.ts",
     "types.ts",
     "README.md",
@@ -48,14 +47,14 @@
     "typecheck": "tsc"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.77.0",
-    "@earendil-works/pi-ai": ">=0.77.0",
-    "@earendil-works/pi-tui": ">=0.77.0"
+    "@earendil-works/pi-coding-agent": ">=0.84.1",
+    "@earendil-works/pi-ai": ">=0.84.1",
+    "@earendil-works/pi-tui": ">=0.84.1"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.77.0",
-    "@earendil-works/pi-ai": "0.77.0",
-    "@earendil-works/pi-tui": "0.77.0",
+    "@earendil-works/pi-coding-agent": "0.84.1",
+    "@earendil-works/pi-ai": "0.84.1",
+    "@earendil-works/pi-tui": "0.84.1",
     "@types/node": "22.19.19",
     "typescript": "5.9.3"
   }