pi-compact-transcript 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alan Hagedorn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+# pi-compact-transcript
+
+A compact transcript extension for [pi](https://pi.dev):
+
+- Collapses hidden thinking blocks into `Thinking...` and consecutive thinking blocks into `Thinking... (Nx)`.
+- Collapses built-in tool calls/results into one-line previews.
+- Consecutive tool uses 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
+
+```bash
+pi install git:github.com/avhagedorn/pi-compact-transcript
+```
+
+Or try it for one run:
+
+```bash
+pi -e git:github.com/avhagedorn/pi-compact-transcript
+```
+
+Reload or restart pi after installing:
+
+```text
+/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:
+
+```json
+{
+  "hideThinkingBlock": true,
+  "outputPad": 0
+}
+```
+
+Set these in `~/.pi/agent/settings.json`, or use `/settings` in pi.
+
+## Notes
+
+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.

package/extensions/compact-transcript.ts

@@ -0,0 +1,286 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	createBashTool,
+	createEditTool,
+	createFindTool,
+	createGrepTool,
+	createLsTool,
+	createReadTool,
+	createWriteTool,
+} from "@earendil-works/pi-coding-agent";
+import { Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+type BuiltInName = "bash" | "read" | "write" | "edit" | "grep" | "find" | "ls";
+
+type ToolInfo = {
+	id: string;
+	name: string;
+	args: any;
+	preview: string;
+	result?: string;
+	invalidate?: () => void;
+};
+
+const BUILT_INS: BuiltInName[] = ["bash", "read", "write", "edit", "grep", "find", "ls"];
+const LABEL = "Thinking...";
+
+const toolCache = new Map<string, ReturnType<typeof createBuiltInTools>>();
+
+function createBuiltInTools(cwd: string) {
+	return {
+		bash: createBashTool(cwd),
+		read: createReadTool(cwd),
+		write: createWriteTool(cwd),
+		edit: createEditTool(cwd),
+		grep: createGrepTool(cwd),
+		find: createFindTool(cwd),
+		ls: createLsTool(cwd),
+	};
+}
+
+function getBuiltInTools(cwd: string) {
+	let tools = toolCache.get(cwd);
+	if (!tools) {
+		tools = createBuiltInTools(cwd);
+		toolCache.set(cwd, tools);
+	}
+	return tools;
+}
+
+function shortenPath(path: unknown): string {
+	if (typeof path !== "string" || !path) return "";
+	const home = homedir();
+	return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+
+function oneLine(value: unknown): string {
+	return String(value ?? "")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+function limitPlain(text: string, max = Math.max(20, (process.stdout.columns || 100) - 6)): string {
+	const clean = oneLine(text);
+	if (clean.length <= max) return clean;
+	return `${clean.slice(0, Math.max(0, max - 1))}…`;
+}
+
+function quote(s: string): string {
+	return JSON.stringify(s);
+}
+
+function previewFor(name: string, args: any): string {
+	switch (name) {
+		case "bash":
+			return `$ ${oneLine(args?.command || "...")}`;
+		case "read": {
+			let out = `read ${shortenPath(args?.path) || "..."}`;
+			if (args?.offset !== undefined || args?.limit !== undefined) {
+				const start = args.offset ?? 1;
+				const end = args.limit !== undefined ? start + args.limit - 1 : "";
+				out += `:${start}${end ? `-${end}` : ""}`;
+			}
+			return out;
+		}
+		case "write": {
+			const lines = typeof args?.content === "string" ? args.content.split("\n").length : 0;
+			return `write ${shortenPath(args?.path) || "..."}${lines ? ` (${lines} lines)` : ""}`;
+		}
+		case "edit": {
+			const edits = Array.isArray(args?.edits) ? args.edits.length : 0;
+			return `edit ${shortenPath(args?.path) || "..."}${edits > 1 ? ` (${edits} edits)` : ""}`;
+		}
+		case "grep": {
+			const pattern = args?.pattern ? quote(String(args.pattern)) : "...";
+			const path = shortenPath(args?.path) || ".";
+			return `grep ${pattern} ${path}${args?.glob ? ` (${args.glob})` : ""}`;
+		}
+		case "find":
+			return `find ${args?.pattern ? quote(String(args.pattern)) : "..."} ${shortenPath(args?.path) || "."}`;
+		case "ls":
+			return `ls ${shortenPath(args?.path) || "."}`;
+		default:
+			return `${name} ${oneLine(JSON.stringify(args ?? {}))}`;
+	}
+}
+
+function resultPreview(result: any): string {
+	const text = Array.isArray(result?.content)
+		? result.content.find((c: any) => c?.type === "text" && typeof c.text === "string")?.text
+		: undefined;
+	if (!text) return "";
+	const lines = String(text).trim().split("\n").filter(Boolean);
+	if (lines.length === 0) return "";
+	if (lines.length === 1) return lines[0];
+	return `${lines.length} lines`;
+}
+
+async function patchAssistantThinkingRenderer() {
+	try {
+		const require = createRequire(import.meta.url);
+		const piMain = require.resolve("@earendil-works/pi-coding-agent");
+		const distDir = dirname(piMain);
+		const assistantModule = await import(
+			pathToFileURL(join(distDir, "modes/interactive/components/assistant-message.js")).href
+		);
+		const themeModule = await import(pathToFileURL(join(distDir, "modes/interactive/theme/theme.js")).href);
+		const Component = assistantModule.AssistantMessageComponent;
+		if (!Component?.prototype || Component.prototype.__compactTranscriptPatched) return;
+		const original = Component.prototype.updateContent;
+
+		Component.prototype.updateContent = function (message: any) {
+			if (!this.hideThinkingBlock) return original.call(this, message);
+
+			this.lastMessage = message;
+			this.contentContainer.clear();
+
+			const visible = message.content.filter(
+				(c: any) => (c.type === "text" && c.text?.trim()) || (c.type === "thinking" && c.thinking?.trim()),
+			);
+			if (visible.length) this.contentContainer.addChild(new Spacer(1));
+
+			for (let i = 0; i < message.content.length; i++) {
+				const content = message.content[i];
+				if (content.type === "text" && content.text?.trim()) {
+					this.contentContainer.addChild(new Markdown(content.text.trim(), this.outputPad, 0, this.markdownTheme));
+					continue;
+				}
+				if (content.type !== "thinking" || !content.thinking?.trim()) continue;
+
+				let count = 1;
+				while (
+					message.content[i + count]?.type === "thinking" &&
+					message.content[i + count]?.thinking?.trim()
+				) {
+					count++;
+				}
+				i += count - 1;
+
+				const label = count > 1 ? `${LABEL} (${count}x)` : LABEL;
+				this.contentContainer.addChild(
+					new Text(themeModule.theme.italic(themeModule.theme.fg("thinkingText", label)), this.outputPad, 0),
+				);
+
+				const hasVisibleAfter = message.content
+					.slice(i + 1)
+					.some((c: any) => (c.type === "text" && c.text?.trim()) || (c.type === "thinking" && c.thinking?.trim()));
+				if (hasVisibleAfter) this.contentContainer.addChild(new Spacer(1));
+			}
+
+			this.hasToolCalls = message.content.some((c: any) => c.type === "toolCall");
+		};
+		Component.prototype.__compactTranscriptPatched = true;
+	} catch {
+		// Best-effort: older/bundled pi builds may not expose internal component modules.
+	}
+}
+
+export default async function (pi: ExtensionAPI) {
+	await patchAssistantThinkingRenderer();
+	let current: ToolInfo[] = [];
+	let byId = new Map<string, ToolInfo>();
+	let consecutiveThinking = 0;
+
+	function thinkingLabel() {
+		return consecutiveThinking > 1 ? `${LABEL} (${consecutiveThinking}x)` : LABEL;
+	}
+
+	function resetTools() {
+		current = [];
+		byId = new Map();
+	}
+
+	function applyThinkingLabel(ctx: ExtensionContext) {
+		ctx.ui.setHiddenThinkingLabel(thinkingLabel());
+	}
+
+	pi.on("session_start", async (_event, ctx) => {
+		applyThinkingLabel(ctx);
+		ctx.ui.setWorkingMessage(LABEL);
+	});
+
+	pi.on("turn_start", (_event, ctx) => {
+		resetTools();
+		consecutiveThinking = 0;
+		applyThinkingLabel(ctx);
+	});
+
+	pi.on("message_update", (event: any, ctx) => {
+		const type = event.assistantMessageEvent?.type;
+		if (type === "thinking_start") {
+			consecutiveThinking++;
+			applyThinkingLabel(ctx);
+			return;
+		}
+		if (type && !type.startsWith("thinking_")) {
+			consecutiveThinking = 0;
+			applyThinkingLabel(ctx);
+		}
+	});
+
+	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);
+		previous?.invalidate?.();
+	});
+
+	pi.on("tool_execution_end", (event: any) => {
+		const info = byId.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({
+			...base,
+			name,
+			label: name,
+			renderShell: "self",
+			async execute(toolCallId: string, params: any, signal: AbortSignal | undefined, onUpdate: any, ctx: ExtensionContext) {
+				const tool = (getBuiltInTools(ctx.cwd) as any)[name];
+				return tool.execute(toolCallId, params, signal, onUpdate, ctx);
+			},
+			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));
+				return text;
+			},
+			renderResult(_result: any, _options: any, _theme: any, _context: any) {
+				return new Text("", 0, 0);
+			},
+		});
+	}
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "pi-compact-transcript",
+  "version": "0.1.0",
+  "description": "A compact transcript extension for pi: collapsed thinking and one-line tool previews.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Alan Hagedorn <avhagedorn@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/avhagedorn/pi-compact-transcript.git"
+  },
+  "bugs": {
+    "url": "https://github.com/avhagedorn/pi-compact-transcript/issues"
+  },
+  "homepage": "https://github.com/avhagedorn/pi-compact-transcript#readme",
+  "keywords": [
+    "pi-package",
+    "pi-coding-agent",
+    "pi-extension",
+    "transcript",
+    "terminal"
+  ],
+  "pi": {
+    "extensions": ["./extensions/compact-transcript.ts"]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "files": [
+    "extensions",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}