pi-compact-transcript 0.5.0 → 0.6.1

package/README.md

@@ -2,25 +2,27 @@
 
 A compact transcript extension for [pi](https://pi.dev).
 
-| Without the extension | With the extension |
+| With the extension | Without the extension|
 |---|---|
-| ![pi transcript without the extension](docs/plugin_disabled.png) | ![pi transcript with the extension](docs/plugin_enabled.png) |
+| <img width="2131" height="552" alt="image" src="https://github.com/user-attachments/assets/4ec40fe8-13da-4415-8274-e26e43cca4e1" /> | <img width="2135" height="1275" alt="image" src="https://github.com/user-attachments/assets/b6fe8d3b-9170-435c-b353-98a6aa84fe7b" />
+ |
 
 What it does:
 
-- Collapses every tool call/result into a one-line preview, including custom/external tools added by other extensions.
-- Each tool row carries a status diamond: blinking gray `◆` while the tool runs, solid green `◆` on success, solid red `◆` on failure.
-- Consecutive uses of the same tool coalesce into a single row, e.g. `◆ 4× read src/foo.ts {12 lines · 8s}`; a different tool starts a new row with its own diamond.
-- Tool rows show durations when they take a second or longer; grouped rows show the total.
-- Failed tools always get their own visible row (red diamond) and end the current burst.
-- Tool rows render dimmed so assistant text stands out.
-- Hidden thinking blocks are suppressed entirely — no `Thinking...` markers.
+- Collapses every tool call/result into a dimmed one-line preview with a status diamond: blinking gray `◆` while running, green on success, red on failure. Durations show at a second or longer.
+- Consecutive uses of the same tool coalesce into a single row, e.g. `◆ 4× read src/foo.ts {12 lines · 8s}`. Failed tools always get their own visible row.
 - Each agent run ends with a one-line summary, e.g. `Read 6 files, edited 2, ran 3 commands, 1 failed · 42s`.
-- Unknown tools preview their most meaningful string argument (command, code, query, path, url, ...) instead of dumping raw JSON args.
-- Expanded tool output still falls back to pi's original renderer, so you can use pi's normal tool expansion when details matter.
-- Minimizes vertical space so long agent runs do not scroll away as quickly.
+- Suppresses `Thinking...` markers when thinking is hidden.
+- Works with custom/external tools from other extensions; unknown tools preview their most meaningful string argument (command, code, query, path, url, ...) instead of raw JSON.
+- Expanded tool output still uses pi's original renderer, so pi's normal tool expansion works when details matter.
 
-## Install from GitHub
+## Install
+
+```bash
+pi install npm:pi-compact-transcript
+```
+
+Or from GitHub:
 
 ```bash
 pi install git:github.com/avhagedorn/pi-compact-transcript
@@ -38,17 +40,9 @@ Reload or restart pi after installing:
 /reload
 ```
 
-## Install from npm
-
-Once published to npm:
-
-```bash
-pi install npm:pi-compact-transcript
-```
-
 ## Recommended settings
 
-The extension works best with hidden thinking and no output padding:
+Works best with hidden thinking and no output padding — set in `~/.pi/agent/settings.json` or via `/settings`:
 
 ```json
 {
@@ -57,8 +51,6 @@ The extension works best with hidden thinking and no output padding:
 }
 ```
 
-Set these in `~/.pi/agent/settings.json`, or use `/settings` in pi.
-
 Thinking suppression only applies when `hideThinkingBlock` is on; with it off, pi renders thinking traces normally.
 
 ## Commands
@@ -69,10 +61,10 @@ Thinking suppression only applies when `hideThinkingBlock` is on; with it off, p
 /compact-transcript status   # show current state
 ```
 
-Toggling applies to the visible transcript immediately — existing rows re-render, no reload needed. The pre-0.5 mode names (`balanced`, `aggressive`, `debug`, `disabled`) are accepted as legacy aliases for `on`/`off`.
+Toggling re-renders the visible transcript immediately — no reload needed. Pre-0.5 mode names (`balanced`, `aggressive`, `debug`, `disabled`) are accepted as legacy aliases for `on`/`off`.
 
 ## Notes
 
-This extension changes display only. Tool execution is still handled by pi and any other extensions that registered or override tools.
+This extension changes display only — tool execution is still handled by pi and any other extensions that registered or override tools.
 
-For built-in and extension tools, compact rendering uses pi's public exported TUI components where available. The cross-tool burst compaction and thinking suppression still rely on pi's current TUI component internals, so if pi changes those internals in a future release, the extension falls back to pi's normal rendering behavior for the affected rows.
+Compact rendering uses pi's public exported TUI components where available. Burst compaction and thinking suppression rely on pi's current TUI internals; if a future pi release changes those, the affected rows fall back to pi's normal rendering.

package/extensions/compact-transcript.ts

@@ -70,6 +70,9 @@ type RuntimeState = {
 	toolComponents: Set<any>;
 	assistantComponents: Set<any>;
 	currentTheme?: Theme;
+	thinkingHidden: boolean;
+	currentThoughtHeading?: string;
+	thoughtAnchorId?: string;
 };
 
 const DEFAULT_CONFIG: CompactTranscriptConfig = {
@@ -117,8 +120,13 @@ function getState(): RuntimeState {
 		runStats: newRunStats(),
 		toolComponents: new Set(),
 		assistantComponents: new Set(),
+		thinkingHidden: true,
 	};
-	return globalWithState[STATE_KEY]!;
+	const runtimeState = globalWithState[STATE_KEY]!;
+	// /reload keeps the global object alive; initialize fields added by newer
+	// versions when an older extension instance created the state object.
+	runtimeState.thinkingHidden ??= true;
+	return runtimeState;
 }
 
 const state = getState();
@@ -259,6 +267,8 @@ function resetToolRun() {
 	state.currentBurst = [];
 	state.hiddenToolIds = new Set();
 	state.runningToolIds = new Set();
+	state.currentThoughtHeading = undefined;
+	state.thoughtAnchorId = undefined;
 	stopBlinkTimer();
 }
 
@@ -310,6 +320,110 @@ function statusMarker(theme: Theme, opts: { running?: boolean; isError?: boolean
 	return theme.fg("dim", "◆ ");
 }
 
+function textSignalHasVisibleContent(assistantMessageEvent: any): boolean {
+	const type = assistantMessageEvent?.type;
+	if (type === "text_delta") {
+		return typeof assistantMessageEvent.delta === "string" && assistantMessageEvent.delta.trim().length > 0;
+	}
+	if (type === "text_end") {
+		return typeof assistantMessageEvent.content === "string" && assistantMessageEvent.content.trim().length > 0;
+	}
+	return false;
+}
+
+function thoughtTickerEnabled(): boolean {
+	// The ticker is a compact replacement for hidden thinking. When thinking is
+	// fully visible, showing the same headline under a tool would be duplicate.
+	return isEnabled() && state.thinkingHidden;
+}
+
+function cleanThoughtHeading(line: string): string {
+	let clean = oneLine(line)
+		.replace(/^#{1,6}\s+/, "")
+		.replace(/^[-*]\s+/, "")
+		.trim();
+	clean = clean
+		.replace(/^\*\*(.+)\*\*$/, "$1")
+		.replace(/^__(.+)__$/, "$1")
+		.replace(/^`(.+)`$/, "$1");
+	return clean.trim();
+}
+
+function extractThoughtHeading(text: unknown): string {
+	if (typeof text !== "string") return "";
+	const firstLine = text.split(/\r?\n/).find((line) => line.trim().length > 0);
+	return firstLine ? cleanThoughtHeading(firstLine) : "";
+}
+
+function latestThoughtHeading(message: any): string {
+	if (!Array.isArray(message?.content)) return "";
+	for (let i = message.content.length - 1; i >= 0; i--) {
+		const content = message.content[i];
+		if (content?.type === "thinking") return extractThoughtHeading(content.thinking);
+	}
+	return "";
+}
+
+function invalidateToolById(id: string | undefined) {
+	if (!id) return;
+	state.toolsById.get(id)?.invalidate?.();
+}
+
+function latestVisibleTool(): ToolInfo | undefined {
+	return Array.from(state.toolsById.values())
+		.reverse()
+		.find((tool) => !tool.hidden);
+}
+
+function clearCurrentThought() {
+	if (!state.currentThoughtHeading && !state.thoughtAnchorId) return;
+	const previousAnchorId = state.thoughtAnchorId;
+	state.currentThoughtHeading = undefined;
+	state.thoughtAnchorId = undefined;
+	invalidateToolById(previousAnchorId);
+}
+
+function setCurrentThought(heading: string) {
+	const nextHeading = oneLine(heading);
+	if (!thoughtTickerEnabled() || !nextHeading) {
+		clearCurrentThought();
+		return;
+	}
+
+	const previousAnchorId = state.thoughtAnchorId;
+	const nextAnchorId = latestVisibleTool()?.id;
+	const changed = state.currentThoughtHeading !== nextHeading || previousAnchorId !== nextAnchorId;
+	state.currentThoughtHeading = nextHeading;
+	state.thoughtAnchorId = nextAnchorId;
+	if (!changed) return;
+
+	invalidateToolById(previousAnchorId);
+	if (nextAnchorId !== previousAnchorId) invalidateToolById(nextAnchorId);
+}
+
+function updateCurrentThoughtFromMessage(message: any) {
+	const heading = latestThoughtHeading(message);
+	// A new thinking block starts empty; keep showing the previous heading until
+	// the replacement has real text so the ticker does not blink off/on between
+	// tool completion and the next streamed thought.
+	if (heading) setCurrentThought(heading);
+}
+
+function anchorCurrentThoughtTo(info: ToolInfo) {
+	if (!thoughtTickerEnabled() || !state.currentThoughtHeading || state.thoughtAnchorId === info.id) return;
+	const previousAnchorId = state.thoughtAnchorId;
+	state.thoughtAnchorId = info.id;
+	invalidateToolById(previousAnchorId);
+	info.invalidate?.();
+}
+
+function currentThoughtLine(toolCallId: string, theme: Theme): string {
+	if (!thoughtTickerEnabled() || state.thoughtAnchorId !== toolCallId || !state.currentThoughtHeading) return "";
+	const prefix = "  ↳ ";
+	const budget = previewWidth((process.stdout.columns || 100) - prefix.length);
+	return theme.fg("dim", prefix) + theme.fg("thinkingText", limitPlain(state.currentThoughtHeading, budget));
+}
+
 function upsertToolInfo(id: string, name: string, args: any, invalidate?: () => void): ToolInfo {
 	let info = state.toolsById.get(id);
 	if (!info) {
@@ -368,9 +482,10 @@ function beginTool(id: string, name: string, args: any) {
 	ensureBlinkTimer();
 	recordToolStart(name, args);
 	joinBurst(info);
+	anchorCurrentThoughtTo(info);
 	// The component may already be on screen from argument streaming; repaint
-	// now so the running marker and burst count appear immediately instead of
-	// waiting for the next result event or blink tick.
+	// now so the running marker, burst count, and thought ticker appear
+	// immediately instead of waiting for the next result event or blink tick.
 	info.invalidate?.();
 }
 
@@ -515,6 +630,8 @@ function patchToolExecutionComponent() {
 		}
 
 		this.selfRenderContainer.addChild(new Text(line, 0, 0));
+		const thoughtLine = currentThoughtLine(this.toolCallId, theme);
+		if (thoughtLine) this.selfRenderContainer.addChild(new Text(thoughtLine, 0, 0));
 	};
 
 	proto.render = function patchedRender(width: number) {
@@ -534,6 +651,8 @@ function patchAssistantMessageComponent() {
 
 	proto.updateContent = function patchedUpdateContent(message: any) {
 		state.assistantComponents.add(this);
+		state.thinkingHidden = !!this.hideThinkingBlock;
+		if (!state.thinkingHidden) clearCurrentThought();
 		if (!isEnabled() || !this.hideThinkingBlock || !Array.isArray(message?.content)) {
 			return originalUpdateContent.call(this, message);
 		}
@@ -549,6 +668,7 @@ function patchAssistantMessageComponent() {
 		const texts = message.content.filter((c: any) => c.type === "text" && c.text?.trim());
 		if (texts.length === 0) return;
 
+		clearCurrentThought();
 		// Assistant text ends a tool burst. The live path also does this via
 		// message_update events; doing it here too keeps hydrated history from
 		// grouping tool rows across turn boundaries.
@@ -733,6 +853,7 @@ export default function compactTranscript(pi: ExtensionAPI) {
 	pi.on("agent_end", (_event, _ctx) => {
 		state.agentActive = false;
 		state.currentBurst = [];
+		clearCurrentThought();
 		state.runningToolIds.clear();
 		stopBlinkTimer();
 		appendRunSummary(pi);
@@ -745,8 +866,14 @@ export default function compactTranscript(pi: ExtensionAPI) {
 	pi.on("message_update", (event, ctx) => {
 		captureTheme(ctx);
 		const type = event.assistantMessageEvent?.type;
-		if (type === "text_delta" || type === "text_start") {
-			// Visible assistant text ends the current tool burst.
+		if (typeof type === "string" && type.startsWith("thinking_")) {
+			updateCurrentThoughtFromMessage(event.message);
+		}
+		if (textSignalHasVisibleContent(event.assistantMessageEvent)) {
+			clearCurrentThought();
+			// Visible assistant text ends the current tool burst. Do not split on
+			// text_start alone: some providers create empty text blocks before a
+			// tool-only turn, and those blocks are hidden from the transcript.
 			state.currentBurst = [];
 		}
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-compact-transcript",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "A compact transcript extension for pi: collapsed thinking summaries and one-line tool previews.",
   "type": "module",
   "license": "MIT",
@@ -21,7 +21,9 @@
     "terminal"
   ],
   "pi": {
-    "extensions": ["./extensions/compact-transcript.ts"]
+    "extensions": [
+      "./extensions/compact-transcript.ts"
+    ]
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",