pi-zentui 0.1.2 → 0.1.3

package/README.md

@@ -86,7 +86,7 @@ On first run, Zentui creates a config file at:
 {
   "icons": {
     "cwd": "󰝰",
-    "git": "",
+    "git": "",
     "ahead": "↑",
     "behind": "↓",
     "diverged": "⇕",
@@ -109,10 +109,19 @@ On first run, Zentui creates a config file at:
     "tokens": "muted",
     "cost": "success",
     "separator": "borderMuted"
+  },
+  "tools": {
+    "style": "compact"
   }
 }
 ```
 
+`tools.style` controls the initial built-in tool output style:
+
+- `compact` — one-line tool calls by default
+- `truncated` — expanded preview with long output truncated
+- `full` — expanded full output
+
 ### Color values
 
 Colors can be:
@@ -129,23 +138,28 @@ This means Zentui works with any Pi theme — it uses your theme's colors by def
 
 ## Development
 
-If you use [mise](https://mise.jdx.dev/):
+```bash
+npm install
+npm run verify
+npm run fmt
+npm run pack:check
+```
+
+### Test in Pi
+
+The project keeps Pi core packages as peer dependencies for runtime and dev dependencies for
+typechecking. To avoid accidentally running the local `node_modules/.bin/pi` shim, the dev scripts use
+the globally installed Pi binary by default:
 
 ```bash
-mise install
-mise run setup
-mise run verify
-mise run fmt
-mise run ci
+npm run pi:dev
+npm run pi:install-local
 ```
 
-Without mise:
+Override the binary if your Pi install is somewhere else:
 
 ```bash
-npm install
-npm run verify
-npm run fmt
-npm run pack:check
+PI_BIN=/path/to/pi npm run pi:dev
 ```
 
 ## Credits

package/extensions/zentui/compact-tools.ts

@@ -0,0 +1,565 @@
+import { homedir } from "node:os";
+import type {
+	AgentToolResult,
+	ExtensionAPI,
+	Theme,
+	ToolDefinition,
+	ToolRenderResultOptions,
+} from "@mariozechner/pi-coding-agent";
+import {
+	createBashToolDefinition,
+	createEditToolDefinition,
+	createFindToolDefinition,
+	createGrepToolDefinition,
+	createLsToolDefinition,
+	createReadToolDefinition,
+	createWriteToolDefinition,
+	getLanguageFromPath,
+	highlightCode,
+	renderDiff,
+} from "@mariozechner/pi-coding-agent";
+import { Box, type Component, Container, Spacer, Text } from "@mariozechner/pi-tui";
+import { type ToolOutputStyle, loadConfig } from "./config";
+
+type BuiltInDefinitions = ReturnType<typeof createBuiltInDefinitions>;
+type ToolArgs = Record<string, unknown>;
+
+type CompactState = {
+	summary?: string;
+	error?: boolean;
+	errorText?: string;
+};
+
+type CompactRenderContext = {
+	args: ToolArgs;
+	state: CompactState;
+	isError: boolean;
+	lastComponent?: Component;
+	invalidate: () => void;
+};
+
+type CompactRenderCall = (args: ToolArgs, theme: Theme, context: CompactRenderContext) => Component;
+type CompactExpandedRenderer = (
+	result: AgentToolResult<unknown>,
+	theme: Theme,
+	context: CompactRenderContext,
+	error: boolean,
+	mode: ExpandedOutputMode,
+) => string;
+type CompactRenderResult = (
+	result: AgentToolResult<unknown>,
+	options: ToolRenderResultOptions,
+	theme: Theme,
+	context: CompactRenderContext,
+) => Component;
+
+type OutputMode = "one-line" | "preview" | "full";
+type ExpandedOutputMode = Exclude<OutputMode, "one-line">;
+type ExpandedBoxStatus = "pending" | "success" | "error";
+type ToolBackground = Parameters<Theme["bg"]>[0];
+
+const PREVIEW_LINES = 12;
+const OUTPUT_MODES: OutputMode[] = ["one-line", "preview", "full"];
+
+let outputMode: OutputMode = "one-line";
+let observedPiExpanded = false;
+
+const home = homedir();
+const definitionsByCwd = new Map<string, BuiltInDefinitions>();
+
+function createBuiltInDefinitions(cwd: string) {
+	return {
+		bash: createBashToolDefinition(cwd),
+		edit: createEditToolDefinition(cwd),
+		find: createFindToolDefinition(cwd),
+		grep: createGrepToolDefinition(cwd),
+		ls: createLsToolDefinition(cwd),
+		read: createReadToolDefinition(cwd),
+		write: createWriteToolDefinition(cwd),
+	};
+}
+
+function getBuiltIns(cwd: string): BuiltInDefinitions {
+	let definitions = definitionsByCwd.get(cwd);
+	if (!definitions) {
+		definitions = createBuiltInDefinitions(cwd);
+		definitionsByCwd.set(cwd, definitions);
+	}
+	return definitions;
+}
+
+function stripAtPrefix(path: string): string {
+	return path.startsWith("@") ? path.slice(1) : path;
+}
+
+function shortPath(path: unknown, fallback = "."): string {
+	if (typeof path !== "string" || path.length === 0) return fallback;
+	const cleaned = stripAtPrefix(path);
+	return cleaned.startsWith(home) ? `~${cleaned.slice(home.length)}` : cleaned;
+}
+
+function quote(value: unknown): string {
+	return `"${String(value ?? "")}"`;
+}
+
+function truncate(value: unknown, max = 120): string {
+	const text = String(value ?? "")
+		.replace(/\s+/g, " ")
+		.trim();
+	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+function plural(count: number, one: string, many = `${one}s`): string {
+	return `${count} ${count === 1 ? one : many}`;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+	return value && typeof value === "object" ? (value as Record<string, unknown>) : {};
+}
+
+function resultDetails(result: AgentToolResult<unknown>): Record<string, unknown> {
+	return asRecord(result.details);
+}
+
+function isResultTruncated(result: AgentToolResult<unknown>): boolean {
+	return Boolean(asRecord(resultDetails(result).truncation).truncated);
+}
+
+function textContent(result: AgentToolResult<unknown>): string {
+	const block = result.content.find((item) => item.type === "text");
+	return block?.type === "text" ? block.text : "";
+}
+
+function hasImage(result: AgentToolResult<unknown>): boolean {
+	return result.content.some((item) => item.type === "image");
+}
+
+function visibleLineCount(text: string): number {
+	return text
+		.split("\n")
+		.map((line) => line.trim())
+		.filter(
+			(line) =>
+				line.length > 0 && !line.startsWith("[Showing ") && !line.startsWith("[Output truncated"),
+		).length;
+}
+
+function firstUsefulLine(text: string): string | undefined {
+	return text
+		.split("\n")
+		.map((line) => line.trim())
+		.find((line) => line.length > 0);
+}
+
+function normalizeDisplayText(text: string): string {
+	return text.replace(/\r/g, "");
+}
+
+function replaceTabs(text: string): string {
+	return text.replace(/\t/g, "   ");
+}
+
+function trimTrailingEmptyLines(lines: string[]): string[] {
+	let end = lines.length;
+	while (end > 0 && lines[end - 1] === "") end--;
+	return lines.slice(0, end);
+}
+
+function limitRenderedText(text: string, mode: ExpandedOutputMode, theme: Theme): string {
+	if (mode === "full") return text;
+
+	const lines = trimTrailingEmptyLines(text.split("\n"));
+	if (lines.length <= PREVIEW_LINES) return lines.join("\n");
+
+	const hidden = lines.length - PREVIEW_LINES;
+	return `${lines.slice(0, PREVIEW_LINES).join("\n")}\n${theme.fg(
+		"dim",
+		`… ${hidden} more lines (Ctrl+O for full)`,
+	)}`;
+}
+
+function nextOutputMode(mode: OutputMode): OutputMode {
+	return OUTPUT_MODES[(OUTPUT_MODES.indexOf(mode) + 1) % OUTPUT_MODES.length] ?? "one-line";
+}
+
+function outputModeForToolStyle(style: ToolOutputStyle): OutputMode {
+	switch (style) {
+		case "full":
+			return "full";
+		case "truncated":
+			return "preview";
+		default:
+			return "one-line";
+	}
+}
+
+function configuredOutputMode(expanded: boolean): OutputMode {
+	const configured = outputModeForToolStyle(loadConfig().tools.style);
+	return configured === "one-line" && expanded ? "preview" : configured;
+}
+
+function syncOutputModeWithPiToggle(expanded: boolean) {
+	if (expanded === observedPiExpanded) return;
+	observedPiExpanded = expanded;
+	outputMode = nextOutputMode(outputMode);
+}
+
+function argPath(context: CompactRenderContext): string | undefined {
+	const rawPath = context.args.path ?? context.args.file_path;
+	return typeof rawPath === "string" ? stripAtPrefix(rawPath) : undefined;
+}
+
+function renderHighlightedSource(
+	source: string,
+	path: string | undefined,
+	theme: Theme,
+	error: boolean,
+	mode: ExpandedOutputMode,
+): string {
+	const normalized = replaceTabs(normalizeDisplayText(source)).trimEnd();
+	if (!normalized) return "";
+	if (error) return limitRenderedText(theme.fg("error", normalized), mode, theme);
+
+	const language = path ? getLanguageFromPath(path) : undefined;
+	if (!language) return limitRenderedText(theme.fg("muted", normalized), mode, theme);
+
+	try {
+		return limitRenderedText(
+			trimTrailingEmptyLines(highlightCode(normalized, language)).join("\n"),
+			mode,
+			theme,
+		);
+	} catch {
+		return limitRenderedText(theme.fg("muted", normalized), mode, theme);
+	}
+}
+
+function highlightShellCommand(command: unknown, theme: Theme): string {
+	const normalized = truncate(command, 180);
+	if (!normalized) return theme.fg("muted", "...");
+
+	try {
+		return trimTrailingEmptyLines(highlightCode(normalized, "bash")).join(" ");
+	} catch {
+		return theme.fg("accent", normalized);
+	}
+}
+
+function renderExpandedBox(content: string, theme: Theme, status: ExpandedBoxStatus) {
+	const background: ToolBackground =
+		status === "error" ? "toolErrorBg" : status === "pending" ? "toolPendingBg" : "toolSuccessBg";
+	const box = new Box(3, 1, (text: string) => theme.bg(background, text));
+	box.addChild(new Text(content, 0, 0));
+	return box;
+}
+
+function renderPlainExpanded(
+	result: AgentToolResult<unknown>,
+	theme: Theme,
+	_context: CompactRenderContext,
+	error: boolean,
+	mode: ExpandedOutputMode,
+): string {
+	return limitRenderedText(
+		theme.fg(error ? "error" : "muted", textContent(result).trimEnd()),
+		mode,
+		theme,
+	);
+}
+
+function renderReadExpanded(
+	result: AgentToolResult<unknown>,
+	theme: Theme,
+	context: CompactRenderContext,
+	error: boolean,
+	mode: ExpandedOutputMode,
+): string {
+	return renderHighlightedSource(textContent(result), argPath(context), theme, error, mode);
+}
+
+function renderBashExpanded(
+	result: AgentToolResult<unknown>,
+	theme: Theme,
+	_context: CompactRenderContext,
+	error: boolean,
+	mode: ExpandedOutputMode,
+): string {
+	const output = textContent(result).trimEnd();
+	return output ? limitRenderedText(theme.fg(error ? "error" : "muted", output), mode, theme) : "";
+}
+
+function renderWriteExpanded(
+	result: AgentToolResult<unknown>,
+	theme: Theme,
+	context: CompactRenderContext,
+	error: boolean,
+	mode: ExpandedOutputMode,
+) {
+	if (error) return renderPlainExpanded(result, theme, context, true, mode);
+	const source =
+		typeof context.args.content === "string" ? context.args.content : textContent(result);
+	return renderHighlightedSource(source, argPath(context), theme, false, mode);
+}
+
+function renderEditExpanded(
+	result: AgentToolResult<unknown>,
+	theme: Theme,
+	context: CompactRenderContext,
+	error: boolean,
+	mode: ExpandedOutputMode,
+): string {
+	if (error) return renderPlainExpanded(result, theme, context, true, mode);
+	const diff = resultDetails(result).diff;
+	if (typeof diff === "string" && diff.length > 0) {
+		return limitRenderedText(renderDiff(diff, { filePath: argPath(context) }), mode, theme);
+	}
+	return renderPlainExpanded(result, theme, context, false, mode);
+}
+
+function setCompactState(context: CompactRenderContext, next: CompactState) {
+	const state = context.state;
+	const changed =
+		state.summary !== next.summary ||
+		state.error !== next.error ||
+		state.errorText !== next.errorText;
+	state.summary = next.summary;
+	state.error = next.error;
+	state.errorText = next.errorText;
+
+	// renderCall runs before renderResult. Re-render once after renderResult stores
+	// the final summary so the count/status can stay on the same compact line.
+	if (changed) queueMicrotask(() => context.invalidate());
+}
+
+function suffix(state: CompactState): string {
+	if (state.errorText) return ` — ${truncate(state.errorText, 100)}`;
+	if (state.summary) return ` (${state.summary})`;
+	return "";
+}
+
+function compactCall(format: (args: ToolArgs, state: CompactState) => string): CompactRenderCall {
+	return (args, theme, context) => {
+		const state = context.state;
+		const component =
+			context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
+		const color = state.error || context.isError ? "error" : "muted";
+		component.setText(theme.fg(color, format(args, state)));
+		return component;
+	};
+}
+
+const compactBashCall: CompactRenderCall = (args, theme, context) => {
+	const state = context.state;
+	const component =
+		context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
+	const command = truncate(args.command, 180);
+	const timeout = args.timeout !== undefined ? ` [timeout=${args.timeout}s]` : "";
+	const meta = `${timeout}${suffix(state)}`;
+
+	if (state.error || context.isError) {
+		component.setText(theme.fg("error", `→ $ ${command}${meta}`));
+	} else {
+		component.setText(
+			`${theme.fg("muted", "→ ")}${theme.fg("accent", "$")} ${highlightShellCommand(
+				command,
+				theme,
+			)}${theme.fg("dim", meta)}`,
+		);
+	}
+
+	return component;
+};
+
+function compactResult(
+	summarize: (
+		result: AgentToolResult<unknown>,
+		context: CompactRenderContext,
+	) => string | undefined,
+	renderExpanded: CompactExpandedRenderer = renderPlainExpanded,
+	gapBeforeExpanded = true,
+): CompactRenderResult {
+	return (result, { expanded, isPartial }, theme, context) => {
+		const output = textContent(result);
+		const error = Boolean(context.isError);
+		const errorText = error ? firstUsefulLine(output) : undefined;
+		const summary = isPartial ? "running" : summarize(result, context);
+
+		setCompactState(context, { summary, error, errorText });
+
+		syncOutputModeWithPiToggle(Boolean(expanded));
+		if (outputMode === "one-line") return new Text("", 0, 0);
+
+		const mode: ExpandedOutputMode = outputMode === "full" ? "full" : "preview";
+		const expandedText = renderExpanded(result, theme, context, error, mode);
+		if (!expandedText || expandedText.trim() === "") return new Text("", 0, 0);
+
+		const status: ExpandedBoxStatus = error ? "error" : isPartial ? "pending" : "success";
+		const box = renderExpandedBox(expandedText, theme, status);
+		if (!gapBeforeExpanded) return box;
+
+		const container = new Container();
+		container.addChild(new Spacer(1));
+		container.addChild(box);
+		return container;
+	};
+}
+
+function summarizeRead(result: AgentToolResult<unknown>): string | undefined {
+	if (hasImage(result)) return "image";
+	const lines = visibleLineCount(textContent(result));
+	const truncated = isResultTruncated(result);
+	return lines > 0 ? `${plural(lines, "line")}${truncated ? ", truncated" : ""}` : undefined;
+}
+
+function summarizeBash(
+	result: AgentToolResult<unknown>,
+	context: CompactRenderContext,
+): string | undefined {
+	const output = textContent(result);
+	if (context.isError) {
+		const exit = output.match(/Command exited with code (\d+)/i)?.[1];
+		if (exit) return `exit ${exit}`;
+	}
+	const lines = visibleLineCount(output);
+	const truncated = isResultTruncated(result);
+	if (lines === 0 || output.trim() === "(no output)") return "done";
+	return `${plural(lines, "line")}${truncated ? ", truncated" : ""}`;
+}
+
+function summarizeEdit(result: AgentToolResult<unknown>): string | undefined {
+	const diff = resultDetails(result).diff;
+	if (typeof diff !== "string") return "done";
+	let additions = 0;
+	let removals = 0;
+	for (const line of diff.split("\n")) {
+		if (line.startsWith("+") && !line.startsWith("+++")) additions++;
+		if (line.startsWith("-") && !line.startsWith("---")) removals++;
+	}
+	return `+${additions}/-${removals}`;
+}
+
+function summarizeWrite(): string {
+	return "written";
+}
+
+function summarizeCount(noun: string, many = `${noun}s`) {
+	return (result: AgentToolResult<unknown>): string | undefined => {
+		const count = visibleLineCount(textContent(result));
+		if (count === 0) return `0 ${many}`;
+		return plural(count, noun, many);
+	};
+}
+
+function registerCompactBuiltIn(
+	pi: ExtensionAPI,
+	name: keyof BuiltInDefinitions,
+	renderCall: CompactRenderCall,
+	renderResult: CompactRenderResult,
+) {
+	const initialDefinition = getBuiltIns(process.cwd())[name] as ToolDefinition;
+
+	pi.registerTool({
+		...initialDefinition,
+		renderShell: "self",
+		async execute(
+			toolCallId: string,
+			params: Parameters<ToolDefinition["execute"]>[1],
+			signal: AbortSignal | undefined,
+			onUpdate: Parameters<ToolDefinition["execute"]>[3],
+			ctx: Parameters<ToolDefinition["execute"]>[4],
+		) {
+			const definition = getBuiltIns(ctx.cwd)[name] as ToolDefinition;
+			return definition.execute(toolCallId, params, signal, onUpdate, ctx);
+		},
+		renderCall: renderCall as NonNullable<ToolDefinition["renderCall"]>,
+		renderResult: renderResult as NonNullable<ToolDefinition["renderResult"]>,
+	});
+}
+
+export function registerCompactTools(pi: ExtensionAPI) {
+	pi.on("session_start", async (_event, ctx) => {
+		observedPiExpanded = ctx.ui.getToolsExpanded();
+		outputMode = configuredOutputMode(observedPiExpanded);
+	});
+
+	registerCompactBuiltIn(
+		pi,
+		"read",
+		compactCall((args, state) => {
+			const options: string[] = [];
+			if (args.offset !== undefined) options.push(`offset=${args.offset}`);
+			if (args.limit !== undefined) options.push(`limit=${args.limit}`);
+			return `→ Read ${shortPath(args.path)}${
+				options.length ? ` [${options.join(", ")}]` : ""
+			}${suffix(state)}`;
+		}),
+		compactResult(summarizeRead, renderReadExpanded),
+	);
+
+	registerCompactBuiltIn(
+		pi,
+		"bash",
+		compactBashCall,
+		compactResult(summarizeBash, renderBashExpanded),
+	);
+
+	registerCompactBuiltIn(
+		pi,
+		"edit",
+		compactCall((args, state) => {
+			const edits = Array.isArray(args.edits) ? ` [${plural(args.edits.length, "edit")}]` : "";
+			return `→ Edit ${shortPath(args.path)}${edits}${suffix(state)}`;
+		}),
+		compactResult(summarizeEdit, renderEditExpanded),
+	);
+
+	registerCompactBuiltIn(
+		pi,
+		"write",
+		compactCall((args, state) => {
+			const lines =
+				typeof args.content === "string"
+					? ` [${plural(args.content.split("\n").length, "line")}]`
+					: "";
+			return `→ Write ${shortPath(args.path)}${lines}${suffix(state)}`;
+		}),
+		compactResult(summarizeWrite, renderWriteExpanded),
+	);
+
+	registerCompactBuiltIn(
+		pi,
+		"find",
+		compactCall((args, state) => {
+			const limit = args.limit !== undefined ? ` [limit=${args.limit}]` : "";
+			return `* Glob ${quote(args.pattern)} in ${shortPath(args.path)}${limit}${suffix(state)}`;
+		}),
+		compactResult(summarizeCount("match", "matches")),
+	);
+
+	registerCompactBuiltIn(
+		pi,
+		"grep",
+		compactCall((args, state) => {
+			const parts: string[] = [];
+			if (args.glob) parts.push(`glob=${args.glob}`);
+			if (args.ignoreCase) parts.push("ignoreCase=true");
+			if (args.literal) parts.push("literal=true");
+			if (args.context !== undefined) parts.push(`context=${args.context}`);
+			if (args.limit !== undefined) parts.push(`limit=${args.limit}`);
+			return `* Grep ${quote(args.pattern)} in ${shortPath(args.path)}${
+				parts.length ? ` [${parts.join(", ")}]` : ""
+			}${suffix(state)}`;
+		}),
+		compactResult(summarizeCount("match", "matches")),
+	);
+
+	registerCompactBuiltIn(
+		pi,
+		"ls",
+		compactCall((args, state) => {
+			const limit = args.limit !== undefined ? ` [limit=${args.limit}]` : "";
+			return `→ List ${shortPath(args.path)}${limit}${suffix(state)}`;
+		}),
+		compactResult(summarizeCount("entry", "entries")),
+	);
+}

package/extensions/zentui/config.ts

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { getAgentDir } from "@mariozechner/pi-coding-agent";
 
 export type ColorSpec = string;
+export type ToolOutputStyle = "compact" | "truncated" | "full";
 
 export type PolishedTuiConfig = {
 	icons: {
@@ -31,6 +32,9 @@ export type PolishedTuiConfig = {
 		cost: ColorSpec;
 		separator: ColorSpec;
 	};
+	tools: {
+		style: ToolOutputStyle;
+	};
 };
 
 export const configPath = join(getAgentDir(), "zentui.json");
@@ -110,6 +114,9 @@ export const defaultConfig: PolishedTuiConfig = {
 		cost: "success",
 		separator: "borderMuted",
 	},
+	tools: {
+		style: "compact",
+	},
 };
 
 function isHexColor(value: string): boolean {
@@ -128,6 +135,18 @@ type ThemeLike = {
 	fg(color: string, text: string): string;
 };
 
+type ConfigRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is ConfigRecord {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function parseToolOutputStyle(value: unknown): ToolOutputStyle {
+	return value === "truncated" || value === "full" || value === "compact"
+		? value
+		: defaultConfig.tools.style;
+}
+
 export function colorize(theme: ThemeLike, color: ColorSpec, text: string): string {
 	if (themeColorTokens.has(color)) {
 		return theme.fg(color, text);
@@ -148,20 +167,34 @@ export function ensureConfigExists(): void {
 	}
 }
 
+export function mergeConfig(parsed: unknown): PolishedTuiConfig {
+	const config = isRecord(parsed) ? parsed : {};
+	const icons = isRecord(config.icons) ? (config.icons as Partial<PolishedTuiConfig["icons"]>) : {};
+	const colors = isRecord(config.colors)
+		? (config.colors as Partial<PolishedTuiConfig["colors"]>)
+		: {};
+	const tools = isRecord(config.tools) ? (config.tools as Partial<PolishedTuiConfig["tools"]>) : {};
+
+	return {
+		icons: {
+			...defaultConfig.icons,
+			...icons,
+		},
+		colors: {
+			...defaultConfig.colors,
+			...colors,
+		},
+		tools: {
+			...defaultConfig.tools,
+			style: parseToolOutputStyle(tools.style),
+		},
+	};
+}
+
 export function loadConfig(): PolishedTuiConfig {
 	try {
 		if (!existsSync(configPath)) return defaultConfig;
-		const parsed = JSON.parse(readFileSync(configPath, "utf8")) as Partial<PolishedTuiConfig>;
-		return {
-			icons: {
-				...defaultConfig.icons,
-				...(parsed.icons ?? {}),
-			},
-			colors: {
-				...defaultConfig.colors,
-				...(parsed.colors ?? {}),
-			},
-		};
+		return mergeConfig(JSON.parse(readFileSync(configPath, "utf8")));
 	} catch {
 		return defaultConfig;
 	}

package/extensions/zentui/index.ts

@@ -6,13 +6,13 @@ import type {
 	Theme,
 } from "@mariozechner/pi-coding-agent";
 import { type EditorTheme, type TUI, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { registerCompactTools } from "./compact-tools";
 import { type PolishedTuiConfig, colorize, ensureConfigExists, loadConfig } from "./config";
 import { type GitStatusSummary, emptyGitStatus, readGitStatus } from "./git";
 import { type RuntimeInfo, readRuntimeInfo } from "./runtime";
-import { PolishedEditor, patchUserMessageComponent } from "./ui";
+import { PolishedEditor, patchUserMessageComponent, restoreUserMessageComponent } from "./ui";
 
 type FooterState = GitStatusSummary & {
-	busy: boolean;
 	modelLabel: string;
 	providerLabel: string;
 	contextLabel: string;
@@ -127,8 +127,9 @@ function formatCwdLabel(cwd: string, cwdIcon: string): string {
 }
 
 export default function (pi: ExtensionAPI) {
+	registerCompactTools(pi);
+
 	const state: FooterState = {
-		busy: false,
 		modelLabel: "no-model",
 		providerLabel: "Unknown",
 		contextLabel: "--",
@@ -267,15 +268,8 @@ export default function (pi: ExtensionAPI) {
 	const installEditor = (ctx: ExtensionContext) => {
 		syncState(ctx);
 
-		let currentEditor: PolishedEditor | undefined;
-		let autocompleteFixed = false;
-
-		type AutocompleteEditorInternals = {
-			autocompleteProvider?: unknown;
-		};
-
-		const editorFactory = (tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) => {
-			const editor = new PolishedEditor(
+		const editorFactory = (tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) =>
+			new PolishedEditor(
 				tui,
 				theme,
 				keybindings,
@@ -287,22 +281,6 @@ export default function (pi: ExtensionAPI) {
 					].join(ctx.ui.theme.fg("borderMuted", "  ")),
 				() => pi.getThinkingLevel(),
 			);
-			currentEditor = editor;
-
-			const originalHandleInput = editor.handleInput.bind(editor);
-			editor.handleInput = (data: string) => {
-				const editorInternals = editor as unknown as AutocompleteEditorInternals;
-				if (!autocompleteFixed && !editorInternals.autocompleteProvider) {
-					autocompleteFixed = true;
-					ctx.ui.setEditorComponent(editorFactory);
-					currentEditor?.handleInput(data);
-					return;
-				}
-				originalHandleInput(data);
-			};
-
-			return editor;
-		};
 
 		ctx.ui.setEditorComponent(editorFactory);
 	};
@@ -321,14 +299,16 @@ export default function (pi: ExtensionAPI) {
 		installUi(ctx);
 	});
 
+	pi.on("session_shutdown", async () => {
+		restoreUserMessageComponent();
+	});
+
 	pi.on("agent_start", async (_event, ctx) => {
-		state.busy = true;
 		syncState(ctx);
 		refresh();
 	});
 
 	pi.on("agent_end", async (_event, ctx) => {
-		state.busy = false;
 		syncState(ctx);
 		scheduleProjectRefresh(ctx);
 		refresh();

package/extensions/zentui/ui.ts

@@ -16,13 +16,22 @@ import {
 const OSC133_ZONE_START = "\x1b]133;A\x07";
 const OSC133_ZONE_END = "\x1b]133;B\x07";
 const OSC133_ZONE_FINAL = "\x1b]133;C\x07";
-const originalUserMessageRender = UserMessageComponent.prototype.render;
+const userMessagePatchKey = "__zentuiUserMessagePatch";
 
 type AutocompleteEditorInternals = {
 	autocompleteList?: Pick<Component, "render">;
 	isShowingAutocomplete?: () => boolean;
 };
 
+type UserMessageRender = (this: UserMessageComponent, width: number) => string[];
+type UserMessagePatchState = {
+	originalRender: UserMessageRender;
+	patchedRender: UserMessageRender;
+};
+type PatchableUserMessagePrototype = typeof UserMessageComponent.prototype & {
+	[userMessagePatchKey]?: UserMessagePatchState;
+};
+
 let currentUiTheme: Theme | undefined;
 
 const TRUECOLOR_BACKGROUND_ANSI = /\x1b\[48;2;\d+;\d+;\d+m/g;
@@ -36,51 +45,74 @@ function stripBackgroundAnsi(text: string): string {
 		.replace(SIMPLE_BACKGROUND_ANSI, "");
 }
 
-function fillStyledLine(
-	content: string,
-	width: number,
-	background?: (text: string) => string,
-): string {
+function fillStyledLine(content: string, width: number): string {
 	const truncated = truncateToWidth(stripBackgroundAnsi(content), width, "");
 	const padWidth = Math.max(0, width - visibleWidth(truncated));
-	const pad =
-		padWidth > 0 ? (background ? background(" ".repeat(padWidth)) : " ".repeat(padWidth)) : "";
+	const pad = padWidth > 0 ? " ".repeat(padWidth) : "";
 	return `${truncated}${pad}`;
 }
 
+function userMessagePrototype(): PatchableUserMessagePrototype {
+	return UserMessageComponent.prototype as PatchableUserMessagePrototype;
+}
+
+function renderPatchedUserMessage(this: UserMessageComponent, width: number): string[] {
+	const originalRender = userMessagePrototype()[userMessagePatchKey]?.originalRender;
+	if (!currentUiTheme || !originalRender) {
+		return originalRender
+			? originalRender.call(this, width)
+			: (Container.prototype.render.call(this, width) as string[]);
+	}
+
+	const railWidth = 2;
+	const innerWidth = Math.max(1, width - railWidth);
+	const baseLines = Container.prototype.render.call(this, innerWidth) as string[];
+	if (baseLines.length === 0) return baseLines;
+
+	const hasLeadingSpacer = baseLines.length > 1 && visibleWidth(baseLines[0] ?? "") === 0;
+	const leadingLines = hasLeadingSpacer ? [baseLines[0] ?? ""] : [];
+	const contentLines = hasLeadingSpacer ? baseLines.slice(1) : baseLines;
+	const rail = `${currentUiTheme.fg("accent", "│")}\x1b[0m `;
+	const border = currentUiTheme.fg("border", "─".repeat(width));
+	const styledLines = contentLines.map((line) => `${rail}${fillStyledLine(line, innerWidth)}`);
+
+	if (styledLines.length === 0) {
+		return leadingLines;
+	}
+
+	const framedLines = [border, ...styledLines, border];
+	framedLines[0] = OSC133_ZONE_START + framedLines[0];
+	framedLines[framedLines.length - 1] =
+		framedLines[framedLines.length - 1] + OSC133_ZONE_END + OSC133_ZONE_FINAL;
+	return [...leadingLines, ...framedLines];
+}
+
 export function patchUserMessageComponent(uiTheme: Theme): void {
 	currentUiTheme = uiTheme;
 
-	const prototype = UserMessageComponent.prototype as {
-		render(width: number): string[];
+	const prototype = userMessagePrototype();
+	const patchState = prototype[userMessagePatchKey] ?? {
+		originalRender: prototype.render,
+		patchedRender: renderPatchedUserMessage,
 	};
-	prototype.render = function (this: UserMessageComponent, width: number): string[] {
-		if (!currentUiTheme) {
-			return originalUserMessageRender.call(this, width);
-		}
+	patchState.patchedRender = renderPatchedUserMessage;
 
-		const railWidth = 2;
-		const innerWidth = Math.max(1, width - railWidth);
-		const baseLines = Container.prototype.render.call(this, innerWidth) as string[];
-		if (baseLines.length === 0) return baseLines;
+	Object.defineProperty(prototype, userMessagePatchKey, {
+		value: patchState,
+		configurable: true,
+	});
+	prototype.render = renderPatchedUserMessage;
+}
 
-		const hasLeadingSpacer = baseLines.length > 1 && visibleWidth(baseLines[0] ?? "") === 0;
-		const leadingLines = hasLeadingSpacer ? [baseLines[0] ?? ""] : [];
-		const contentLines = hasLeadingSpacer ? baseLines.slice(1) : baseLines;
-		const rail = `${currentUiTheme.fg("accent", "│")}\x1b[0m `;
-		const border = currentUiTheme.fg("border", "─".repeat(width));
-		const styledLines = contentLines.map((line) => `${rail}${fillStyledLine(line, innerWidth)}`);
+export function restoreUserMessageComponent(): void {
+	currentUiTheme = undefined;
 
-		if (styledLines.length === 0) {
-			return leadingLines;
-		}
+	const prototype = userMessagePrototype();
+	const patchState = prototype[userMessagePatchKey];
+	if (!patchState || prototype.render !== patchState.patchedRender) return;
 
-		const framedLines = [border, ...styledLines, border];
-		framedLines[0] = OSC133_ZONE_START + framedLines[0];
-		framedLines[framedLines.length - 1] =
-			framedLines[framedLines.length - 1] + OSC133_ZONE_END + OSC133_ZONE_FINAL;
-		return [...leadingLines, ...framedLines];
-	};
+	prototype.render = patchState.originalRender;
+	delete prototype[userMessagePatchKey];
 }
 
 export class PolishedEditor extends CustomEditor {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-zentui",
-	"version": "0.1.2",
+	"version": "0.1.3",
 	"description": "A Starship-inspired statusline and Opencode-style TUI for Pi.",
 	"type": "module",
 	"license": "MIT",
@@ -18,6 +18,8 @@
 		"lint": "biome check .",
 		"typecheck": "tsc --noEmit",
 		"test": "vitest run",
+		"pi:dev": "${PI_BIN:-/opt/homebrew/bin/pi} --no-extensions -e ./extensions/zentui/index.ts",
+		"pi:install-local": "${PI_BIN:-/opt/homebrew/bin/pi} install ./ -l",
 		"fmt": "biome format --write .",
 		"fmt:check": "biome format --check .",
 		"verify": "npm run lint && npm run typecheck && npm run test",
@@ -38,9 +40,9 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^1.9.4",
-		"@mariozechner/pi-ai": "^0.65.2",
-		"@mariozechner/pi-coding-agent": "^0.65.2",
-		"@mariozechner/pi-tui": "^0.65.2",
+		"@mariozechner/pi-ai": "^0.73.0",
+		"@mariozechner/pi-coding-agent": "^0.73.0",
+		"@mariozechner/pi-tui": "^0.73.0",
 		"@types/node": "^25.5.2",
 		"typescript": "^6.0.2",
 		"vitest": "^3.2.4"