pi-compact-transcript 0.1.0 → 0.2.1

package/README.md

@@ -3,8 +3,9 @@
 A compact transcript extension for [pi](https://pi.dev):
 
 - Collapses hidden thinking blocks into `Thinking...` and consecutive thinking blocks into `Thinking... (Nx)`.
+- Adds a short, visible next-step summary to collapsed thinking rows without exposing raw chain-of-thought.
 - Collapses built-in tool calls/results into one-line previews.
-- Consecutive tool uses are summarized as `Used N tools <latest tool preview>`.
+- Consecutive tool uses in the same agent run are summarized as `Used N tools <latest tool preview>`.
 - Minimizes vertical space so long agent runs do not scroll away as quickly.
 
 ## Install from GitHub
@@ -50,4 +51,4 @@ Set these in `~/.pi/agent/settings.json`, or use `/settings` in pi.
 
 This extension overrides the built-in tool renderers for `bash`, `read`, `write`, `edit`, `grep`, `find`, and `ls`. It delegates execution to pi's original built-in tools; only display is changed.
 
-The consecutive-thinking collapse uses pi's current internal assistant-message renderer. If pi changes that internal path in a future release, the extension falls back to the normal hidden-thinking label behavior.
+The consecutive-thinking collapse and compact self-rendered tool rows use pi's current internal TUI components. If pi changes those internal paths in a future release, the extension falls back to the normal hidden-thinking/tool rendering behavior.

package/extensions/compact-transcript.ts

@@ -28,6 +28,9 @@ type ToolInfo = {
 const BUILT_INS: BuiltInName[] = ["bash", "read", "write", "edit", "grep", "find", "ls"];
 const LABEL = "Thinking...";
 
+let currentTools: ToolInfo[] = [];
+let toolsById = new Map<string, ToolInfo>();
+
 const toolCache = new Map<string, ReturnType<typeof createBuiltInTools>>();
 
 function createBuiltInTools(cwd: string) {
@@ -119,7 +122,61 @@ function resultPreview(result: any): string {
 	return `${lines.length} lines`;
 }
 
-async function patchAssistantThinkingRenderer() {
+function toolCallName(block: any): string {
+	return block?.name ?? block?.toolName ?? block?.tool_name ?? block?.tool?.name ?? "tool";
+}
+
+function toolCallArgs(block: any): any {
+	return block?.args ?? block?.input ?? block?.arguments ?? block?.tool?.args ?? {};
+}
+
+function resetToolRun() {
+	currentTools = [];
+	toolsById = new Map();
+}
+
+function upsertToolInfo(id: string, name: string, args: any, invalidate?: () => void): ToolInfo {
+	let info = toolsById.get(id);
+	if (!info) {
+		info = { id, name, args, preview: previewFor(name, args) };
+		toolsById.set(id, info);
+		if (!currentTools.some((tool) => tool.id === id)) currentTools.push(info);
+	}
+	info.name = name;
+	info.args = args;
+	info.preview = previewFor(name, args);
+	if (invalidate) info.invalidate = invalidate;
+	return info;
+}
+
+function compactToolLine(toolCallId: string, name: string, args: any, theme: any, invalidate?: () => void, result?: any): string {
+	const info = upsertToolInfo(toolCallId, name, args, invalidate);
+	const suffix = resultPreview(result);
+	if (suffix) info.result = suffix;
+
+	if (currentTools[currentTools.length - 1]?.id !== toolCallId) return "";
+
+	const details = info.result ? `${info.preview} {${oneLine(info.result)}}` : info.preview;
+	if (currentTools.length === 1) return theme.fg("muted", limitPlain(details));
+	const prefix = `Used ${currentTools.length} tools `;
+	return theme.fg("toolTitle", prefix) + theme.fg("muted", limitPlain(details, Math.max(20, (process.stdout.columns || 100) - prefix.length - 6)));
+}
+
+function nextStepSummary(content: any[], fromIndex: number): string {
+	const tools = content.slice(fromIndex + 1).filter((c: any) => c?.type === "toolCall");
+	if (tools.length === 0) return " Next, I’ll continue from this reasoning and respond with the result. I’ll keep the visible output brief.";
+
+	const first = tools[0];
+	const preview = limitPlain(previewFor(toolCallName(first), toolCallArgs(first)), 90);
+	if (tools.length === 1) {
+		return ` Next, I’ll use ${preview}. I’ll inspect the result and decide the next visible step from there.`;
+	}
+	const last = tools[tools.length - 1];
+	const lastPreview = limitPlain(previewFor(toolCallName(last), toolCallArgs(last)), 70);
+	return ` Next, I’ll run ${tools.length} tool calls, starting with ${preview}. I’ll use the latest result to continue, ending this batch around ${lastPreview}.`;
+}
+
+async function patchInternalRenderers() {
 	try {
 		const require = createRequire(import.meta.url);
 		const piMain = require.resolve("@earendil-works/pi-coding-agent");
@@ -127,7 +184,48 @@ async function patchAssistantThinkingRenderer() {
 		const assistantModule = await import(
 			pathToFileURL(join(distDir, "modes/interactive/components/assistant-message.js")).href
 		);
+		const toolExecutionModule = await import(
+			pathToFileURL(join(distDir, "modes/interactive/components/tool-execution.js")).href
+		);
 		const themeModule = await import(pathToFileURL(join(distDir, "modes/interactive/theme/theme.js")).href);
+
+		const ToolExecutionComponent = toolExecutionModule.ToolExecutionComponent;
+		if (ToolExecutionComponent?.prototype && !ToolExecutionComponent.prototype.__compactTranscriptPatched) {
+			const originalRender = ToolExecutionComponent.prototype.render;
+			ToolExecutionComponent.prototype.updateDisplay = function () {
+				this.__compactTranscriptForceSelf = true;
+				this.hideComponent = false;
+				this.selfRenderContainer.clear();
+				this.imageComponents = [];
+				this.imageSpacers = [];
+
+				const line = compactToolLine(
+					this.toolCallId,
+					this.toolName,
+					this.args,
+					themeModule.theme,
+					() => {
+						this.invalidate();
+						this.ui?.requestRender?.();
+					},
+					this.result,
+				);
+
+				if (!line) {
+					this.hideComponent = true;
+					return;
+				}
+
+				this.selfRenderContainer.addChild(new Text(line, 0, 0));
+			};
+			ToolExecutionComponent.prototype.render = function (width: number) {
+				if (this.hideComponent) return [];
+				if (this.__compactTranscriptForceSelf) return this.selfRenderContainer.render(width);
+				return originalRender.call(this, width);
+			};
+			ToolExecutionComponent.prototype.__compactTranscriptPatched = true;
+		}
+
 		const Component = assistantModule.AssistantMessageComponent;
 		if (!Component?.prototype || Component.prototype.__compactTranscriptPatched) return;
 		const original = Component.prototype.updateContent;
@@ -161,8 +259,9 @@ async function patchAssistantThinkingRenderer() {
 				i += count - 1;
 
 				const label = count > 1 ? `${LABEL} (${count}x)` : LABEL;
+				const summary = nextStepSummary(message.content, i);
 				this.contentContainer.addChild(
-					new Text(themeModule.theme.italic(themeModule.theme.fg("thinkingText", label)), this.outputPad, 0),
+					new Text(themeModule.theme.italic(themeModule.theme.fg("thinkingText", limitPlain(`${label}${summary}`))), this.outputPad, 0),
 				);
 
 				const hasVisibleAfter = message.content
@@ -180,9 +279,7 @@ async function patchAssistantThinkingRenderer() {
 }
 
 export default async function (pi: ExtensionAPI) {
-	await patchAssistantThinkingRenderer();
-	let current: ToolInfo[] = [];
-	let byId = new Map<string, ToolInfo>();
+	await patchInternalRenderers();
 	let consecutiveThinking = 0;
 
 	function thinkingLabel() {
@@ -190,8 +287,7 @@ export default async function (pi: ExtensionAPI) {
 	}
 
 	function resetTools() {
-		current = [];
-		byId = new Map();
+		resetToolRun();
 	}
 
 	function applyThinkingLabel(ctx: ExtensionContext) {
@@ -203,8 +299,11 @@ export default async function (pi: ExtensionAPI) {
 		ctx.ui.setWorkingMessage(LABEL);
 	});
 
-	pi.on("turn_start", (_event, ctx) => {
+	pi.on("agent_start", () => {
 		resetTools();
+	});
+
+	pi.on("turn_start", (_event, ctx) => {
 		consecutiveThinking = 0;
 		applyThinkingLabel(ctx);
 	});
@@ -219,49 +318,24 @@ export default async function (pi: ExtensionAPI) {
 		if (type && !type.startsWith("thinking_")) {
 			consecutiveThinking = 0;
 			applyThinkingLabel(ctx);
+			if (type === "text_delta" || type === "text_start") resetTools();
 		}
 	});
 
 	pi.on("tool_execution_start", (event: any) => {
-		const previous = current[current.length - 1];
-		const info: ToolInfo = {
-			id: event.toolCallId,
-			name: event.toolName,
-			args: event.args,
-			preview: previewFor(event.toolName, event.args),
-		};
-		current.push(info);
-		byId.set(info.id, info);
+		const previous = currentTools[currentTools.length - 1];
+		upsertToolInfo(event.toolCallId, event.toolName, event.args);
 		previous?.invalidate?.();
 	});
 
 	pi.on("tool_execution_end", (event: any) => {
-		const info = byId.get(event.toolCallId);
+		const info = toolsById.get(event.toolCallId);
 		if (!info) return;
 		const suffix = resultPreview(event.result);
 		if (suffix) info.result = suffix;
 		info.invalidate?.();
 	});
 
-	function compactLine(toolCallId: string, name: string, args: any, theme: any, context: any): string {
-		let info = byId.get(toolCallId);
-		if (!info) {
-			info = { id: toolCallId, name, args, preview: previewFor(name, args) };
-			byId.set(toolCallId, info);
-			if (!current.some((t) => t.id === toolCallId)) current.push(info);
-		}
-		info.invalidate = context.invalidate;
-		info.args = args;
-		info.preview = previewFor(name, args);
-
-		if (current[current.length - 1]?.id !== toolCallId) return "";
-
-		const details = info.result ? `${info.preview} {${oneLine(info.result)}}` : info.preview;
-		if (current.length === 1) return theme.fg("muted", limitPlain(details));
-		const prefix = `Used ${current.length} tools `;
-		return theme.fg("toolTitle", prefix) + theme.fg("muted", limitPlain(details, Math.max(20, (process.stdout.columns || 100) - prefix.length - 6)));
-	}
-
 	for (const name of BUILT_INS) {
 		const base = getBuiltInTools(process.cwd())[name] as any;
 		pi.registerTool({
@@ -275,7 +349,7 @@ export default async function (pi: ExtensionAPI) {
 			},
 			renderCall(args: any, theme: any, context: any) {
 				const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-				text.setText(compactLine(context.toolCallId, name, args, theme, context));
+				text.setText(compactToolLine(context.toolCallId, name, args, theme, context.invalidate));
 				return text;
 			},
 			renderResult(_result: any, _options: any, _theme: any, _context: any) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-compact-transcript",
-  "version": "0.1.0",
-  "description": "A compact transcript extension for pi: collapsed thinking and one-line tool previews.",
+  "version": "0.2.1",
+  "description": "A compact transcript extension for pi: collapsed thinking summaries and one-line tool previews.",
   "type": "module",
   "license": "MIT",
   "author": "Alan Hagedorn <avhagedorn@gmail.com>",