@xiliumz/pi-minimal 1.0.0 → 1.1.0

package/README.md

@@ -32,6 +32,16 @@ Restart pi or run `/reload`.
 | Spinner | Shown in the prompt while the agent runs |
 | Header / footer | Removed |
 | `/info` / `F8` | Model, thinking level, context %, tokens, cost, session file/id |
+| Tool rows / `Ctrl+O` | Cycles **grouped** → **title** → **collapsed** → **full**. Starts grouped |
+
+Tool views:
+
+- **grouped** — back-to-back tool calls collapse into one `N tools` line; a lone call shows its name
+- **title** — one line per call, tool name only (red when the call failed)
+- **collapsed** — pi's default truncated preview
+- **full** — pi's normal expanded output
+
+Assistant text, thinking, and user messages end a group.
 
 Multiline input and slash-command autocomplete start at column 0 (under `$ `).
 Soft-wrapped continuations use the full terminal width — only the first visual line shares space with `$ `.
@@ -42,6 +52,10 @@ Soft-wrapped continuations use the full terminal width — only the first visual
 Pi resets extension UI before the old session context goes stale, then re-runs
 `session_start` so this layout comes back. Extension-side fix is not available.
 
+`Ctrl+O` follows your `app.tools.expand` keybinding and shows the new view as
+`Tool output: <view>`. `/export` renders tools in
+the current view — switch to **full** first for complete HTML.
+
 ## Develop
 
 ```bash
@@ -58,7 +72,9 @@ Layout:
 
 ```
 extensions/index.ts   # pi entry (registers hooks + commands)
-src/editor.ts         # bash prompt CustomEditor
+src/editor.ts         # bash prompt CustomEditor (+ Ctrl+O hook)
+src/tool-view.ts      # grouped / title / full tool renderers
+src/tool-runs.ts      # tracks back-to-back tool calls
 src/info.ts           # /info UI + token stats
 src/git.ts            # branch + dirty
 src/format.ts         # cwd/tokens helpers

package/extensions/index.ts

@@ -6,6 +6,7 @@
  *   $ |
  *
  * Header/footer chrome removed. Session stats via /info.
+ * Ctrl+O cycles tool rows: grouped (`N tools`) → title → collapsed → full.
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -13,6 +14,8 @@ import type { TUI } from "@earendil-works/pi-tui";
 import { createBashPromptEditor } from "../src/editor.js";
 import { fetchGitState, type GitState } from "../src/git.js";
 import { showInfoUi } from "../src/info.js";
+import { ToolRuns } from "../src/tool-runs.js";
+import { createToolViewRenderer, nextToolView, type ToolView } from "../src/tool-view.js";
 import { EmptyComponent } from "../src/ui.js";
 
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -23,6 +26,28 @@ export default function bashLayoutExtension(pi: ExtensionAPI): void {
 	let isWorking = false;
 	let spinnerIndex = 0;
 	let spinnerTimer: ReturnType<typeof setInterval> | undefined;
+	let activeCtx: ExtensionContext | undefined;
+
+	const toolState = { view: "grouped" as ToolView, runs: new ToolRuns() };
+	const toolRenderer = createToolViewRenderer(toolState);
+	pi.registerToolRenderer(toolRenderer.resolve);
+
+	// pi only redraws rows when the expanded flag changes, so flip it twice.
+	const repaintTools = (ctx: ExtensionContext) => {
+		const expanded = toolState.view === "full";
+		ctx.ui.setToolsExpanded(!expanded);
+		ctx.ui.setToolsExpanded(expanded);
+	};
+
+	const rebuildToolRuns = (ctx: ExtensionContext) => {
+		toolState.runs.clear();
+		toolRenderer.clear();
+		for (const entry of ctx.sessionManager.getBranch()) {
+			if (entry.type === "message") toolState.runs.add(entry.message);
+			else toolState.runs.break();
+		}
+		repaintTools(ctx);
+	};
 
 	const stopSpinner = () => {
 		if (spinnerTimer) {
@@ -49,9 +74,30 @@ export default function bashLayoutExtension(pi: ExtensionAPI): void {
 		onMount(tui: TUI) {
 			activeTui = tui;
 		},
+		onToolsExpand() {
+			if (!activeCtx) return;
+			toolState.view = nextToolView(toolState.view);
+			repaintTools(activeCtx);
+			// Info notices reuse pi's status line, replacing its `collapsed/expanded` text.
+			activeCtx.ui.notify(`Tool output: ${toolState.view}`, "info");
+		},
 	};
 
+	pi.on("message_end", (event) => {
+		const changed = toolState.runs.add(event.message);
+		if (toolState.view === "grouped") toolRenderer.redraw(changed);
+	});
+
+	pi.on("session_tree", (_event, ctx) => {
+		if (ctx.mode === "tui") rebuildToolRuns(ctx);
+	});
+
+	pi.on("session_compact", (_event, ctx) => {
+		if (ctx.mode === "tui") rebuildToolRuns(ctx);
+	});
+
 	pi.on("agent_start", () => {
+		toolState.runs.break();
 		isWorking = true;
 		stopSpinner();
 		spinnerTimer = setInterval(() => {
@@ -73,6 +119,7 @@ export default function bashLayoutExtension(pi: ExtensionAPI): void {
 	pi.on("session_shutdown", () => {
 		stopSpinner();
 		activeTui = undefined;
+		activeCtx = undefined;
 	});
 
 	pi.on("session_start", (_event, ctx) => {
@@ -81,6 +128,8 @@ export default function bashLayoutExtension(pi: ExtensionAPI): void {
 		ctx.ui.setHeader(() => new EmptyComponent());
 		ctx.ui.setFooter(() => new EmptyComponent());
 		ctx.ui.setWorkingVisible(false);
+		activeCtx = ctx;
+		rebuildToolRuns(ctx);
 
 		void refreshGit(ctx.cwd);
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xiliumz/pi-minimal",
-	"version": "1.0.0",
+	"version": "1.1.0",
 	"description": "Bash-style prompt layout for pi — ~/path (branch*): with /info",
 	"type": "module",
 	"license": "MIT",
@@ -42,9 +42,9 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"devDependencies": {
-		"@earendil-works/pi-ai": "^0.83.0",
-		"@earendil-works/pi-coding-agent": "^0.83.0",
-		"@earendil-works/pi-tui": "^0.83.0",
+		"@earendil-works/pi-ai": "^1.3.0",
+		"@earendil-works/pi-coding-agent": "^1.3.0",
+		"@earendil-works/pi-tui": "^1.3.0",
 		"@types/node": "^26.1.2",
 		"typescript": "^7.0.2"
 	}

package/src/editor.ts

@@ -21,6 +21,8 @@ export interface BashPromptState {
 	spinnerFrame: string;
 	/** Called when the editor mounts so the extension can request re-renders. */
 	onMount: (tui: TUI) => void;
+	/** Replaces pi's `app.tools.expand` (Ctrl+O) toggle. Extensions cannot bind that key directly. */
+	onToolsExpand: () => void;
 }
 
 /** Subset of Editor internals used for dual-width soft-wrap. */
@@ -52,9 +54,12 @@ export function createBashPromptEditor(
 	return class BashPromptEditor extends CustomEditor {
 		/** Columns reserved on the first visual line for `$ `. */
 		private promptInset = 0;
+		/** CustomEditor keeps its own copy private. */
+		private readonly keys: KeybindingsManager;
 
 		constructor(tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) {
 			super(tui, theme, keybindings, { paddingX: 0 });
+			this.keys = keybindings;
 			// pi-tui's Editor declares `private layoutText`; TS forbids a subclass
 			// member with that name (TS2415/TS2322), but JS ignores `private` at
 			// runtime — so install the override as an instance property instead.
@@ -63,6 +68,14 @@ export function createBashPromptEditor(
 			state.onMount(tui);
 		}
 
+		override handleInput(data: string): void {
+			if (this.keys.matches(data, "app.tools.expand")) {
+				state.onToolsExpand();
+				return;
+			}
+			super.handleInput(data);
+		}
+
 		/** Host may push settings padding — keep 0 so prompt math stays correct. */
 		override setPaddingX(_paddingX: number): void {
 			super.setPaddingX(0);

package/src/tool-runs.ts

@@ -0,0 +1,66 @@
+import type { MessageEndEvent } from "@earendil-works/pi-coding-agent";
+
+type TranscriptMessage = MessageEndEvent["message"];
+
+export interface ToolRunPosition {
+	/** First call of the run — the one that draws `N tools`. */
+	isHead: boolean;
+	/** Number of calls in the run so far. */
+	count: number;
+}
+
+/**
+ * Groups tool calls that appear back to back in the transcript. A run ends at
+ * any visible non-tool content: assistant text, thinking, user or custom
+ * messages. Tool results never end a run.
+ */
+export class ToolRuns {
+	private current: string[] = [];
+	private readonly runById = new Map<string, string[]>();
+
+	clear(): void {
+		this.current = [];
+		this.runById.clear();
+	}
+
+	/** Feed one finished message. Returns tool call ids whose run changed. */
+	add(message: TranscriptMessage): string[] {
+		if (message.role === "toolResult") return [];
+		if (message.role !== "assistant") {
+			this.current = [];
+			return [];
+		}
+
+		const changed: string[] = [];
+		for (const block of message.content) {
+			if (block.type !== "toolCall") {
+				if (isVisible(block)) this.current = [];
+				continue;
+			}
+			if (this.runById.has(block.id)) continue;
+			const head = this.current[0];
+			if (head) changed.push(head);
+			this.current.push(block.id);
+			this.runById.set(block.id, this.current);
+			changed.push(block.id);
+		}
+		return changed;
+	}
+
+	/** Ends the open run, e.g. at a compaction or other non-message entry. */
+	break(): void {
+		this.current = [];
+	}
+
+	position(toolCallId: string): ToolRunPosition | undefined {
+		const run = this.runById.get(toolCallId);
+		if (!run) return undefined;
+		return { isHead: run[0] === toolCallId, count: run.length };
+	}
+}
+
+function isVisible(block: { type: string; text?: string; thinking?: string }): boolean {
+	if (block.type === "text") return Boolean(block.text?.trim());
+	if (block.type === "thinking") return Boolean(block.thinking?.trim());
+	return true;
+}

package/src/tool-view.ts

@@ -0,0 +1,192 @@
+import {
+	keyHint,
+	type AgentToolResult,
+	type Theme,
+	type ToolRendererResolver,
+	type ToolRenderers,
+} from "@earendil-works/pi-coding-agent";
+import { Box, Text, type Component } from "@earendil-works/pi-tui";
+import type { ToolRuns } from "./tool-runs.js";
+import { EmptyComponent } from "./ui.js";
+
+/** pi does not export `ToolRenderContext` from its entry point. */
+type ToolRenderContext = Parameters<NonNullable<ToolRenderers["renderCall"]>>[2];
+
+/**
+ * How tool rows are drawn; Ctrl+O cycles them in this order.
+ * - grouped: back-to-back calls collapse into one `N tools` line
+ * - title:     one line per call with just the tool name
+ * - collapsed: pi's default truncated preview
+ * - full:      pi's normal expanded output
+ */
+export type ToolView = "grouped" | "title" | "collapsed" | "full";
+
+const NEXT_VIEW: Record<ToolView, ToolView> = {
+	grouped: "title",
+	title: "collapsed",
+	collapsed: "full",
+	full: "grouped",
+};
+
+export function nextToolView(view: ToolView): ToolView {
+	return NEXT_VIEW[view];
+}
+
+/** Views drawn by pi-minimal itself rather than the tool's own renderers. */
+function isSummaryView(view: ToolView): boolean {
+	return view === "grouped" || view === "title";
+}
+
+/** Same limits pi uses for tools without renderers. */
+const PREVIEW_LINES = 10;
+const PREVIEW_ARGS_CHARS = 100;
+
+export interface ToolViewState {
+	readonly view: ToolView;
+	readonly runs: ToolRuns;
+}
+
+/** Per-row bookkeeping: the row's redraw hook, plus the base renderer's components and our frame for collapsed/full view. */
+interface RowCache {
+	redraw?: () => void;
+	call?: Component;
+	result?: Component;
+	frame?: Box;
+}
+
+export interface ToolViewRenderer {
+	resolve: ToolRendererResolver;
+	/** Redraw rows already on screen, e.g. after their run grew. */
+	redraw(toolCallIds: string[]): void;
+	/** Drop per-row caches, e.g. when the transcript is rebuilt. */
+	clear(): void;
+}
+
+/**
+ * Renderer resolver that lets pi-minimal decide what every tool row shows,
+ * including MCP and other extensions' tools.
+ */
+export function createToolViewRenderer(state: ToolViewState): ToolViewRenderer {
+	const rows = new Map<string, RowCache>();
+	return {
+		resolve: (toolName, next) => wrapRenderers(toolName, next(), state, rows),
+		redraw: (toolCallIds) => {
+			for (const id of toolCallIds) rows.get(id)?.redraw?.();
+		},
+		clear: () => rows.clear(),
+	};
+}
+
+/**
+ * Rows always use `renderShell: "self"` — pi fixes the shell when a row is
+ * created, and only "self" lets a hidden row take zero lines. Full view
+ * redraws pi's default box itself.
+ */
+function wrapRenderers(
+	toolName: string,
+	base: ToolRenderers | undefined,
+	state: ToolViewState,
+	rows: Map<string, RowCache>,
+): ToolRenderers {
+	const row = (id: string) => {
+		let cache = rows.get(id);
+		if (!cache) rows.set(id, (cache = {}));
+		return cache;
+	};
+
+	return {
+		renderShell: "self",
+
+		renderCall(args, theme, context) {
+			const cache = row(context.toolCallId);
+			cache.redraw = context.invalidate;
+			if (isSummaryView(state.view)) return summaryLine(toolName, theme, context, state);
+
+			const baseContext = { ...context, lastComponent: cache.call };
+			cache.call = base?.renderCall
+				? base.renderCall(args, theme, baseContext)
+				: new Text(formatArgs(toolName, args, theme, context.expanded), 0, 0);
+			if (base?.renderShell === "self") return cache.call;
+
+			cache.frame = new Box(context.outputPad, 1, rowBackground(theme, context));
+			cache.frame.addChild(cache.call);
+			return cache.frame;
+		},
+
+		renderResult(result, options, theme, context) {
+			if (isSummaryView(state.view)) return new EmptyComponent();
+
+			const cache = row(context.toolCallId);
+			const baseContext = { ...context, lastComponent: cache.result };
+			cache.result = base?.renderResult
+				? base.renderResult(result, options, theme, baseContext)
+				: fallbackResult(result, theme, options.expanded);
+			if (base?.renderShell === "self" || !cache.frame) return cache.result;
+
+			// Default-shell tools draw call + result inside one box, like pi does.
+			cache.frame.addChild(cache.result);
+			return new EmptyComponent();
+		},
+	};
+}
+
+function summaryLine(
+	toolName: string,
+	theme: Theme,
+	context: ToolRenderContext,
+	state: ToolViewState,
+): Component {
+	const background = rowBackground(theme, context);
+	const position = state.view === "grouped" ? state.runs.position(context.toolCallId) : undefined;
+	if (position && position.count > 1) {
+		if (!position.isHead) return new EmptyComponent();
+		const label = theme.fg("toolTitle", theme.bold(`${position.count} tools`));
+		return new Text(label, context.outputPad, 1, background);
+	}
+	const color = context.isError ? "error" : "toolTitle";
+	return new Text(theme.fg(color, theme.bold(toolName)), context.outputPad, 1, background);
+}
+
+function rowBackground(theme: Theme, context: ToolRenderContext): (text: string) => string {
+	if (context.isPartial) return (text) => theme.bg("toolPendingBg", text);
+	if (context.isError) return (text) => theme.bg("toolErrorBg", text);
+	return (text) => theme.bg("toolSuccessBg", text);
+}
+
+/**
+ * Tools without their own renderer: name plus one `key: value` line per
+ * argument, or a one-line `key=value` preview when collapsed.
+ */
+function formatArgs(toolName: string, args: unknown, theme: Theme, expanded: boolean): string {
+	const header = theme.fg("toolTitle", theme.bold(toolName));
+	if (!args || typeof args !== "object") return header;
+	if (!expanded) {
+		const pairs = Object.entries(args)
+			.map(([key, value]) => `${key}=${JSON.stringify(value) ?? String(value)}`)
+			.join(" ");
+		if (!pairs) return header;
+		const preview = pairs.length > PREVIEW_ARGS_CHARS ? `${pairs.slice(0, PREVIEW_ARGS_CHARS - 3)}...` : pairs;
+		return `${header} ${theme.fg("muted", preview)}`;
+	}
+	const lines = Object.entries(args).map(([key, value]) => {
+		const text = typeof value === "string" ? value : (JSON.stringify(value, null, 2) ?? String(value));
+		return `  ${key}: ${text.replace(/\r/g, "").split("\n").join("\n    ")}`;
+	});
+	return lines.length > 0 ? `${header}\n${theme.fg("muted", lines.join("\n"))}` : header;
+}
+
+function fallbackResult(result: AgentToolResult<unknown>, theme: Theme, expanded: boolean): Component {
+	const output = result.content
+		.flatMap((block) => (block.type === "text" ? [block.text] : []))
+		.join("\n")
+		.trim();
+	if (!output) return new EmptyComponent();
+	const lines = output.split("\n");
+	const shown = expanded ? lines : lines.slice(0, PREVIEW_LINES);
+	let text = shown.map((line) => theme.fg("toolOutput", line)).join("\n");
+	const remaining = lines.length - shown.length;
+	if (remaining > 0) {
+		text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
+	}
+	return new Text(text, 0, 0);
+}