@runminton/pi-tidy-tools 0.1.0

package/README.md

@@ -0,0 +1,67 @@
+# pi-clean-tool-render
+
+A compact tool-rendering extension for [Pi](https://github.com/earendil-works/pi-mono) (the pi-coding-agent TUI). It overrides the rendering of `bash`, `edit` and `write` so tool output stays out of your way: collapsed into a tiny summary by default, expanded on demand per tool.
+
+[中文版](README.zh-CN.md)
+
+## Features
+
+- **Collapsed by default** — each tool shows a short summary (at most 3 lines) with an ellipsis for omitted content.
+- **Per-tool expansion** — expand exactly the tool you care about, with one shortcut each:
+
+  | Shortcut | Tool |
+  |---|---|
+  | `Ctrl+Alt+E` | `edit` |
+  | `Ctrl+Alt+W` | `write` |
+  | `Ctrl+Alt+B` | `bash` |
+
+- **Independent of the global `Ctrl+O`** — Pi's built-in "expand everything" toggle does not affect these three tools. Each tool has exactly two states: collapsed summary ↔ full official rendering.
+- **Official renderers on expansion** — expanded views delegate to Pi's built-in renderers, so the full diff preview and syntax highlighting still work.
+- **Fast** — rendering caches wrapped output and only processes the preview lines: roughly 13µs per frame for a 2000-line output, instead of ~3ms before.
+
+## Usage
+
+Load the extension:
+
+```bash
+pi -e ./tidy-tools.ts
+```
+
+Or install as a pi package:
+
+```bash
+pi install pi-tidy-tools
+```
+
+Or copy `tidy-tools.ts` into `~/.pi/agent/extensions/` (global) or `.pi/extensions/` (project) and restart Pi.
+
+Then toggle each tool with `Ctrl+Alt+E` / `Ctrl+Alt+W` / `Ctrl+Alt+B`. A notification shows the current state; press again to collapse.
+
+## Keyboard protocol notes
+
+Pi negotiates the [Kitty keyboard protocol](https://sw.kovidgoyal.net/kitty/keyboard-protocol/) (CSI-u sequences) when the terminal supports it — Windows Terminal, WezTerm, Kitty, Ghostty and others do. Under that protocol, `Ctrl+Alt+letter` is encoded with the **control-character codepoint**: `Ctrl+Alt+E` arrives as `\x1b[5;3:1u` (5 = Ctrl+E, modifier = Alt). Pi's keybinding layer, however, recognizes the ASCII-codepoint form (`\x1b[101;7u`, ASCII `e` + Ctrl|Alt modifier). If the terminal sends the former and Pi only understands the latter, the shortcut silently does nothing.
+
+This extension ships a small input bridge: it rewrites the three shortcuts' sequences into the form Pi understands **before** they reach the keybinding layer, no matter which encoding your terminal sends:
+
+- Kitty control-char form (`\x1b[5;3:1u`)
+- Legacy form (`ESC` + control char, e.g. `\x1b\x05`)
+- ASCII-codepoint form (`\x1b[101;7u`)
+
+All other input passes through untouched.
+
+If a shortcut still does nothing on your machine, check:
+
+1. **Terminal or input method swallows the key.** Some terminals and IMEs (e.g. Chinese input methods, Windows Alt-menu accelerators) intercept `Ctrl+Alt+...` before Pi ever sees it. Try a different combination or a different terminal.
+2. **tmux / screen.** If Pi runs inside tmux with the default configuration, tmux's own key handling may interfere.
+3. **Custom keys.** The bindings are registered in `tidy-tools.ts` via `pi.registerShortcut(...)` — edit the key strings there to rebind. Pi's built-in global expansion (`Ctrl+O`, `app.tools.expand`) is configured separately via `~/.pi/agent/keybindings.json`.
+
+## Development
+
+```bash
+# Type-check with the repo tsconfig (resolves Pi types via the symlinked
+# global install in node_modules/)
+tsc --noEmit
+
+# Smoke test: renders collapsed/expanded states with a fake extension host, and
+# benchmarks per-frame cost. See the scripts in the repo's test notes.
+```

package/README.zh-CN.md

@@ -0,0 +1,65 @@
+# pi-clean-tool-render
+
+为 [Pi](https://github.com/earendil-works/pi-mono)（pi-coding-agent 的 TUI）打造的精简工具渲染扩展。它覆盖了 `bash`、`edit`、`write` 的渲染方式：默认折叠成一行小摘要，需要时按工具单独展开，让工具输出不打扰你。
+
+[English](README.md)
+
+## 特性
+
+- **默认折叠** —— 每个工具只显示简短摘要（最多 3 行），省略的内容用 `...` 标记。
+- **按工具单独展开** —— 只展开你关心的那一个工具，每个工具一个快捷键：
+
+  | 快捷键 | 工具 |
+  |---|---|
+  | `Ctrl+Alt+E` | `edit` |
+  | `Ctrl+Alt+W` | `write` |
+  | `Ctrl+Alt+B` | `bash` |
+
+- **与全局 `Ctrl+O` 互不影响** —— Pi 内置的"全部展开"开关不会影响这三个工具。每个工具只有两种状态：折叠摘要 ↔ 官方完整渲染。
+- **展开时使用官方渲染器** —— 完整展开的内容委托给 Pi 内置渲染器，完整的 diff 预览和语法高亮依然可用。
+- **性能好** —— 渲染结果有缓存，且只处理预览行的文本：2000 行输出每帧约 13 微秒，修复前是约 3 毫秒。
+
+## 使用方法
+
+加载扩展：
+
+```bash
+pi -e ./tidy-tools.ts
+```
+
+或者作为 pi 包安装：
+
+```bash
+pi install pi-tidy-tools
+```
+
+或者把 `tidy-tools.ts` 复制到 `~/.pi/agent/extensions/`（全局）或 `.pi/extensions/`（项目级），然后重启 Pi。
+
+之后用 `Ctrl+Alt+E` / `Ctrl+Alt+W` / `Ctrl+Alt+B` 切换对应工具的展开状态。按下时会弹通知提示当前状态；再按一次收起。
+
+## 键盘协议说明（重要）
+
+Pi 会在终端支持时协商 [Kitty 键盘协议](https://sw.kovidgoyal.net/kitty/keyboard-protocol/)（CSI-u 序列）——Windows Terminal、WezTerm、Kitty、Ghostty 等都支持。在该协议下，`Ctrl+Alt+字母` 使用**控制字符码**编码：`Ctrl+Alt+E` 到达时是 `\x1b[5;3:1u`（5 = Ctrl+E 的控制字符，修饰位 = Alt）。而 Pi 的按键匹配层只识别 **ASCII 码形式**（`\x1b[101;7u`，即 ASCII `e` + Ctrl|Alt 修饰位）。如果终端发送前者、Pi 只认后者，快捷键就会无声失效——这就是不同终端行为差异的来源。
+
+本扩展内置了一个小的输入桥：在按键到达 Pi 的匹配层**之前**，把这三个快捷键的序列改写成 Pi 能识别的形式。无论你的终端发送哪种编码都能工作：
+
+- Kitty 控制字符形式（`\x1b[5;3:1u`）
+- 传统形式（`ESC` + 控制字符，如 `\x1b\x05`）
+- ASCII 码形式（`\x1b[101;7u`）
+
+其他所有输入原样通过，不受影响。
+
+如果你的快捷键仍然没反应，请依次检查：
+
+1. **终端或输入法吞掉了按键。** 有些终端和输入法（例如中文输入法、Windows 的 Alt 菜单加速键）会在 Pi 收到按键之前把它拦截。换一个组合键或换一个终端试试。
+2. **tmux / screen。** 如果 Pi 运行在 tmux 默认配置里，tmux 自己的按键处理可能干扰。
+3. **自定义按键。** 绑定在 `tidy-tools.ts` 里通过 `pi.registerShortcut(...)` 注册——改那里的按键字符串即可重新绑定。Pi 内置的全局展开（`Ctrl+O`，即 `app.tools.expand`）则单独通过 `~/.pi/agent/keybindings.json` 配置。
+
+## 开发
+
+```bash
+# 类型检查（通过仓库 tsconfig 解析 Pi 类型，依赖 node_modules/ 中指向全局安装的软链）
+tsc --noEmit
+
+# 冒烟测试与性能基准：用假扩展宿主渲染折叠/展开状态并测量每帧开销（见仓库测试说明）
+```

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@runminton/pi-tidy-tools",
+  "version": "0.1.0",
+  "description": "Tidy tool rendering for the pi TUI: collapse bash/edit/write into compact summaries and expand on demand with Ctrl+Alt+B/W/E.",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "tidy-tools.ts",
+    "README.md",
+    "README.zh-CN.md"
+  ],
+  "pi": {
+    "extensions": [
+      "./tidy-tools.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.84.0",
+    "@earendil-works/pi-tui": ">=0.84.0"
+  },
+  "keywords": [
+    "pi",
+    "pi-extension",
+    "tui",
+    "tools",
+    "rendering"
+  ]
+}

package/tidy-tools.ts

@@ -0,0 +1,492 @@
+/**
+ * Compact Tool Rendering Extension
+ *
+ * Overrides the TUI rendering of bash, edit and write while delegating
+ * execution to the official implementations:
+ * - Collapsed: show a small summary with an ellipsis for long content.
+ * - Expanded: Ctrl+Alt+E (edit), Ctrl+Alt+W (write), Ctrl+Alt+B (bash)
+ *   toggle each tool between collapsed and fully expanded rendering.
+ * - The global Ctrl+O tool expansion does not affect these three tools.
+ *
+ * Usage:
+ *   pi -e ./tidy-tools.ts
+ */
+
+import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import {
+    createBashTool,
+    createBashToolDefinition,
+    createEditToolDefinition,
+    createWriteToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+import type { EditToolDetails } from "@earendil-works/pi-coding-agent";
+import {
+    Box,
+    Container,
+    Text,
+    type Component,
+    sliceByColumn,
+    visibleWidth,
+    wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+
+const MAX_COLLAPSED_COMMAND_LINES = 1;
+const MAX_COLLAPSED_CONTENT_LINES = 3;
+// bash 折叠输出：1 行预览 + 1 行计数提示（共 2 行）。
+const MAX_COLLAPSED_BASH_OUTPUT_LINES = 2;
+
+/**
+ * Truncate rendered rows to at most maxLines, keeping the beginning.
+ * The last line is shortened and an ellipsis marks omitted content.
+ */
+function truncateRows(rows: string[], maxLines: number, ellipsis: string, width: number): string[] {
+    if (rows.length <= maxLines) {
+        return rows;
+    }
+
+    const lines = rows.slice(0, maxLines);
+    const lastIndex = lines.length - 1;
+    const lastLine = lines[lastIndex] ?? "";
+    const ellipsisWidth = visibleWidth(ellipsis);
+
+    if (ellipsisWidth >= width) {
+        lines[lastIndex] = sliceByColumn(ellipsis, 0, Math.max(1, width), true);
+    } else {
+        const contentWidth = width - ellipsisWidth;
+        lines[lastIndex] = `${sliceByColumn(lastLine, 0, contentWidth, true)}${ellipsis}`;
+    }
+
+    return lines;
+}
+
+function firstLine(text: string | undefined): string {
+    if (!text) return "";
+    const line = text.split("\n")[0] ?? "";
+    return line.length > 80 ? `${line.slice(0, 77)}...` : line;
+}
+
+function errorText(result: { content: { type: string; text?: string }[] }): string {
+    return result.content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text ?? "")
+        .join("\n");
+}
+
+function diffStats(diff: string): { additions: number; removals: number } {
+    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 };
+}
+
+/**
+ * Render text with a width-aware maximum number of lines.
+ * The beginning is kept and an ellipsis marks omitted content.
+ */
+class LimitedLinesText implements Component {
+    constructor(
+        private readonly text: string,
+        private readonly maxLines: number,
+        private readonly ellipsis: string,
+    ) {}
+
+    private cachedWidth?: number;
+    private cachedLines?: string[];
+
+    render(width: number): string[] {
+        // The TUI calls render() on every frame. Cache the wrapped result so
+        // a frame only re-wraps when the width actually changes.
+        if (this.cachedLines !== undefined && this.cachedWidth === width) {
+            return this.cachedLines;
+        }
+        const lines = truncateRows(
+            wrapTextWithAnsi(this.text, Math.max(1, width)),
+            this.maxLines,
+            this.ellipsis,
+            width,
+        );
+        this.cachedWidth = width;
+        this.cachedLines = lines;
+        return lines;
+    }
+
+    invalidate(): void {
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+}
+
+class CollapsedToolShell extends Box {
+    private callComponent?: Component;
+    private resultComponent?: Component;
+
+    constructor(theme: any, background: string) {
+        super(1, 1, (text) => theme.bg(background, text));
+    }
+
+    setBackground(theme: any, background: string): void {
+        this.setBgFn((text) => theme.bg(background, text));
+    }
+
+    setCall(component: Component): void {
+        this.callComponent = component;
+        this.rebuild();
+    }
+
+    setResult(component: Component): void {
+        this.resultComponent = component;
+        this.rebuild();
+    }
+
+    private rebuild(): void {
+        this.clear();
+        if (this.callComponent) this.addChild(this.callComponent);
+        if (this.resultComponent) this.addChild(this.resultComponent);
+    }
+}
+
+function getCollapsedToolShell(state: any, theme: any, background: string): CollapsedToolShell {
+    const shell = (state.collapsedToolShell as CollapsedToolShell | undefined) ?? new CollapsedToolShell(theme, background);
+    state.collapsedToolShell = shell;
+    shell.setBackground(theme, background);
+    return shell;
+}
+
+function getCollapsedBackground(isPartial: boolean, isError: boolean): string {
+    if (isPartial) return "toolPendingBg";
+    return isError ? "toolErrorBg" : "toolSuccessBg";
+}
+
+// Per-tool expansion state, toggled by Ctrl+Alt+E/W/B. Independent of the
+// global tool-output expansion (Ctrl+O).
+const toolExpanded = new Map<string, boolean>([
+    ["bash", false],
+    ["edit", true],
+    ["write", true],
+]);
+
+// Some terminals (Kitty keyboard protocol flag-1 mode) encode Ctrl+letter as
+// a CSI-u sequence using the control character code without a Ctrl modifier
+// bit, e.g. Ctrl+Alt+E arrives as \x1b[5;3:1u (5 = Ctrl+E, mod = Alt). Pi
+// only recognizes the ASCII-code + full-modifier form (\x1b[101;7u), so we
+// rewrite the three shortcuts into the form Pi understands. All other input
+// passes through unchanged.
+const CTRL_CODE_TO_KEY: Record<number, string> = {
+    5: "e", // Ctrl+E
+    23: "w", // Ctrl+W
+    2: "b", // Ctrl+B
+};
+const ALT_MODIFIER = 2;
+
+function convertCtrlAltSequence(data: string): string | undefined {
+    const match = data.match(/^\x1b\[(\d+);(\d+)(?::(\d+))?u$/);
+    if (!match) return undefined;
+    const code = Number(match[1]);
+    const modifier = Number(match[2]) - 1; // CSI-u modifiers are 1-indexed
+    const key = CTRL_CODE_TO_KEY[code];
+    if (!key || (modifier & ALT_MODIFIER) === 0) return undefined;
+    const eventSuffix = match[3] ? `:${match[3]}` : "";
+    return `\x1b[${key.charCodeAt(0)};7${eventSuffix}u`; // 7 = Ctrl|Alt (1-indexed)
+}
+
+function toggleToolExpanded(ctx: ExtensionContext, name: string): void {
+    toolExpanded.set(name, !(toolExpanded.get(name) ?? false));
+    const globalExpanded = ctx.ui.getToolsExpanded();
+    // Force every tool row to re-render. The global value is restored
+    // immediately, so only the rows' renderers refresh, not the global state.
+    ctx.ui.setToolsExpanded(!globalExpanded);
+    ctx.ui.setToolsExpanded(globalExpanded);
+    ctx.ui.notify(`${name}: ${toolExpanded.get(name) ? "expanded" : "collapsed"}`, "info");
+}
+
+// Cache the official tool implementation by working directory, as pi may run
+// the same extension against more than one session cwd.
+const bashToolCache = new Map<string, ReturnType<typeof createBashTool>>();
+const bashDefCache = new Map<string, ReturnType<typeof createBashToolDefinition>>();
+
+function getBashTool(cwd: string) {
+    let tool = bashToolCache.get(cwd);
+    if (!tool) {
+        tool = createBashTool(cwd);
+        bashToolCache.set(cwd, tool);
+    }
+    return tool;
+}
+
+function getBashDef(cwd: string) {
+    let def = bashDefCache.get(cwd);
+    if (!def) {
+        def = createBashToolDefinition(cwd);
+        bashDefCache.set(cwd, def);
+    }
+    return def;
+}
+
+/**
+ * Re-register a built-in tool with collapsed rendering and official
+ * rendering when that tool is expanded via its own shortcut. The built-in
+ * render shell is preserved so expanded views keep their native layout.
+ */
+function registerCollapsibleTool(
+    pi: ExtensionAPI,
+    getDef: (cwd: string) => ToolDefinition<any, any, any>,
+    collapsedCall: (args: any, theme: any) => Component,
+    collapsedResult: (result: any, options: any, theme: any, context: any) => Component,
+) {
+    const def = getDef(process.cwd());
+    const usesSelfShell = def.renderShell === "self";
+    pi.registerTool({
+        name: def.name,
+        label: def.label,
+        description: def.description,
+        promptSnippet: def.promptSnippet,
+        promptGuidelines: def.promptGuidelines,
+        parameters: def.parameters,
+        prepareArguments: def.prepareArguments,
+        constrainedSampling: def.constrainedSampling,
+        // Omit renderShell so Pi inherits each built-in tool's native shell.
+        // In particular, edit uses "self" for its original expanded layout.
+
+        async execute(toolCallId, params, signal, onUpdate, ctx) {
+            return getDef(ctx.cwd).execute(toolCallId, params, signal, onUpdate, ctx);
+        },
+
+        renderCall(args, theme, context) {
+            const def = getDef(context.cwd);
+            if (toolExpanded.get(def.name) && def.renderCall) {
+                return def.renderCall(
+                    args as never,
+                    theme as never,
+                    { ...context, lastComponent: undefined } as never,
+                );
+            }
+            const component = collapsedCall(args, theme);
+            if (!usesSelfShell) return component;
+
+            const shell = getCollapsedToolShell(
+                context.state,
+                theme,
+                getCollapsedBackground(context.isPartial, context.isError),
+            );
+            shell.setCall(component);
+            return shell;
+        },
+
+        renderResult(result, options, theme, context) {
+            const def = getDef(context.cwd);
+            if (toolExpanded.get(def.name) && def.renderResult) {
+                return def.renderResult(
+                    result as never,
+                    options as never,
+                    theme as never,
+                    { ...context, lastComponent: undefined } as never,
+                );
+            }
+            const component = collapsedResult(result, options, theme, context);
+            if (!usesSelfShell) return component;
+
+            const shell = getCollapsedToolShell(
+                context.state,
+                theme,
+                getCollapsedBackground(options.isPartial, context.isError),
+            );
+            shell.setResult(component);
+            return new Container();
+        },
+    });
+}
+
+// Cache the official tool definitions by working directory, as pi may run
+// the same extension against more than one session cwd.
+const editDefCache = new Map<string, ToolDefinition<any, any, any>>();
+const writeDefCache = new Map<string, ToolDefinition<any, any, any>>();
+
+function getEditDef(cwd: string) {
+    let def = editDefCache.get(cwd);
+    if (!def) {
+        def = createEditToolDefinition(cwd);
+        editDefCache.set(cwd, def);
+    }
+    return def;
+}
+
+function getWriteDef(cwd: string) {
+    let def = writeDefCache.get(cwd);
+    if (!def) {
+        def = createWriteToolDefinition(cwd);
+        writeDefCache.set(cwd, def);
+    }
+    return def;
+}
+
+export default function (pi: ExtensionAPI) {
+    pi.registerTool({
+        name: "bash",
+        label: "bash",
+        description:
+            "Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last 2000 lines or 50KB (whichever is hit first).",
+        parameters: getBashTool(process.cwd()).parameters,
+
+        async execute(toolCallId, params, signal, onUpdate, ctx) {
+            const tool = getBashTool(ctx.cwd);
+            return tool.execute(toolCallId, params, signal, onUpdate);
+        },
+
+        renderCall(args, theme, context) {
+            if (toolExpanded.get("bash")) {
+                const def = getBashDef(context.cwd);
+                if (def.renderCall) {
+                    return def.renderCall(
+                        args as never,
+                        theme as never,
+                        // One-key full expansion for bash: skip the official
+                        // preview so Ctrl+Alt+B shows the complete output.
+                        { ...context, expanded: true, lastComponent: undefined } as never,
+                    );
+                }
+            }
+
+            const command = args.command || "...";
+            const timeout = args.timeout as number | undefined;
+            const timeoutSuffix = timeout ? theme.fg("muted", ` (timeout ${timeout}s)`) : "";
+            const renderedCommand = theme.fg("toolTitle", theme.bold(`$ ${command}`)) + timeoutSuffix;
+
+            return new LimitedLinesText(
+                renderedCommand,
+                MAX_COLLAPSED_COMMAND_LINES,
+                theme.fg("muted", "..."),
+            );
+        },
+
+        renderResult(result, options, theme, context) {
+            if (toolExpanded.get("bash")) {
+                const def = getBashDef(context.cwd);
+                if (def.renderResult) {
+                    return def.renderResult(
+                        result as never,
+                        // One-key full expansion for bash: skip the official
+                        // preview so Ctrl+Alt+B shows the complete output.
+                        { ...options, expanded: true } as never,
+                        theme as never,
+                        { ...context, lastComponent: undefined } as never,
+                    );
+                }
+            }
+
+            const output = errorText(result).trim().replace(/\r/g, "");
+            if (context.isError) {
+                return new LimitedLinesText(
+                    theme.fg("error", firstLine(output) || "failed"),
+                    MAX_COLLAPSED_CONTENT_LINES,
+                    theme.fg("muted", "..."),
+                );
+            }
+            // Preview only the first line. Wrapping the full output on every
+            // frame is what made the TUI lag with large outputs.
+            const allLines = output.split("\n");
+            const previewLines = allLines.slice(0, 1).map((line) => theme.fg("toolOutput", line));
+            if (allLines.length > 1) {
+                previewLines.push(
+                    theme.fg("muted", `... (${allLines.length - 1} more lines)`),
+                );
+            }
+            return new LimitedLinesText(
+                previewLines.join("\n") || theme.fg("muted", "(no output)"),
+                MAX_COLLAPSED_BASH_OUTPUT_LINES,
+                theme.fg("muted", "..."),
+            );
+        },
+    });
+
+    // --- Edit tool: collapsed diff summary ---
+    registerCollapsibleTool(
+        pi,
+        getEditDef,
+        (args, theme) => {
+            const path = String(args.path ?? "");
+            const edits: { oldText?: string; newText?: string }[] = Array.isArray(args.edits) ? args.edits : [];
+            let text = theme.fg("toolTitle", theme.bold("edit ")) + theme.fg("accent", path);
+            if (edits.length > 0) {
+                text += theme.fg("dim", ` (${edits.length} block${edits.length > 1 ? "s" : ""})`);
+            }
+            return new LimitedLinesText(text, 1, theme.fg("muted", "..."));
+        },
+        (result, _options, theme, context) => {
+            if (context.isError) {
+                return new LimitedLinesText(
+                    theme.fg("error", `failed: ${firstLine(errorText(result))}`),
+                    1,
+                    theme.fg("muted", "..."),
+                );
+            }
+            const diff = (result.details as EditToolDetails | undefined)?.diff;
+            if (!diff) {
+                return new Text(theme.fg("success", "applied"), 0, 0);
+            }
+            const { additions, removals } = diffStats(diff);
+            return new Text(
+                theme.fg("success", "applied") + theme.fg("dim", ` +${additions} -${removals}`),
+                0,
+                0,
+            );
+        },
+    );
+
+    // --- Write tool: collapsed shows path + first lines ---
+    registerCollapsibleTool(
+        pi,
+        getWriteDef,
+        (args, theme) => {
+            const path = String(args.path ?? "");
+            const content = String(args.content ?? "");
+            const lines = content.split("\n");
+            let text = theme.fg("toolTitle", theme.bold("write ")) + theme.fg("accent", path);
+            text += theme.fg("dim", ` (${lines.length} lines)`);
+            if (content) {
+                const preview = lines
+                    .slice(0, MAX_COLLAPSED_CONTENT_LINES - 1)
+                    .map((line) => theme.fg("toolOutput", line));
+                if (lines.length > MAX_COLLAPSED_CONTENT_LINES) {
+                    preview.push(
+                        theme.fg("muted", `... (${lines.length - (MAX_COLLAPSED_CONTENT_LINES - 1)} more lines)`),
+                    );
+                }
+                text += `\n${preview.join("\n")}`;
+            }
+            return new LimitedLinesText(text, MAX_COLLAPSED_CONTENT_LINES, theme.fg("muted", "..."));
+        },
+        (result, _options, theme, context) => {
+            if (context.isError) {
+                return new Text(theme.fg("error", `failed: ${firstLine(errorText(result))}`), 0, 0);
+            }
+            return new Text(theme.fg("success", "done"), 0, 0);
+        },
+    );
+
+    // --- Per-tool expansion shortcuts, independent of the global Ctrl+O ---
+    pi.registerShortcut("ctrl+alt+e", {
+        description: "Toggle edit expansion",
+        handler: (ctx) => toggleToolExpanded(ctx, "edit"),
+    });
+    pi.registerShortcut("ctrl+alt+w", {
+        description: "Toggle write expansion",
+        handler: (ctx) => toggleToolExpanded(ctx, "write"),
+    });
+    pi.registerShortcut("ctrl+alt+b", {
+        description: "Toggle bash expansion",
+        handler: (ctx) => toggleToolExpanded(ctx, "bash"),
+    });
+
+    // Some terminals encode Ctrl+Alt+letter as a control-character CSI-u
+    // sequence. Rewrite those three sequences before they reach the editor.
+    pi.on("session_start", (_event, ctx) => {
+        ctx.ui.onTerminalInput?.((data) => {
+            const converted = convertCtrlAltSequence(data);
+            return converted ? { data: converted } : undefined;
+        });
+    });
+}
+