@bismawy/pi-arnative 0.1.0

package/extensions/tools.ts

@@ -0,0 +1,942 @@
+/**
+ * Codex/Claude-Code style tool boxes: every tool call in its own box.
+ *   ╭────────────────────────────╮
+ *   │ 󰔟 $ cmd smart…             │  running (spinner, gone once finished)
+ *   ╰────────────────────────────╯
+ *   ╭────────────────────────────╮
+ *   │ ✓ $ cmd smart…      0.1s   │  final, collapsed; duration right-aligned
+ *   │ 󱞩 first output line        │
+ *   ╰────────────────────────────╯
+ * Click / ctrl+e = full title + detail (output dim; edit = toolDiff*).
+ * Collapsed summary: bash/write `󱞩 first output line`; grep/find/read numeric
+ * (→ N matches / → N files / N lines); edit `󱞩 +N / -M`. Plain tools show no
+ * summary line when expanded (output is already full) — no duplicated first line.
+ * Duration is right-aligned and space-aware (title truncated via visibleWidth when
+ * it doesn't fit); empty when unmeasured (restored sessions).
+ * Colors: tool name accent, paths/links tint, box lines + 󱞩 dim. Execution is a
+ * pure delegate (spread of the built-in tools).
+ * "has a result" lives in context.state, read at render() -> restore/reload safe,
+ * no stale 󰔟 box. The gap between boxes (built-in Spacer) is stripped by a render
+ * patch (same pattern as the footer patch).
+ * Third-party tools with no renderer of their own (memory_write, scratchpad, MCP…)
+ * get the same treatment: shell "self" + box with a one-line summary and
+ * `[ctrl+o to expand]`; full detail only when expanded.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+	createBashTool,
+	createEditTool,
+	createFindTool,
+	createGrepTool,
+	createReadTool,
+	createWriteTool,
+	getMarkdownTheme,
+	keyText,
+	ToolExecutionComponent,
+} from "@earendil-works/pi-coding-agent";
+import { Markdown, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { homedir } from "node:os";
+import { renderBoxLines as box } from "../lib/box.ts";
+
+type Theme = { fg(color: string, text: string): string; bg?(color: string, text: string): string };
+type TResult = { content: Array<{ type: string; text?: string }>; isError?: boolean; details?: any };
+type TCtx = { isError?: boolean; toolCallId?: string; args?: any; state?: Record<string, unknown> };
+type Res = (r: TResult, th: Theme, tint: (s: string) => string, isErr: boolean, expanded: boolean) => string;
+
+const cwd = process.cwd();
+const TIMINGS = new Map<string, number>(); // duration ms per tool call (one run)
+
+// Running icon 󰔟 󱦠 󱦟: 500ms spin frames from a ticker that only runs while
+// a tool is active (idle = no wasteful re-renders).
+const FRAMES = ["󰔟", "󱦠", "󱦟"];
+let ACTIVE = 0;
+let TICK: ReturnType<typeof setInterval> | null = null;
+let requestRenderFn: (() => void) | null = null;
+
+function syncTicker(): void {
+	if (ACTIVE > 0 && !TICK) {
+		TICK = setInterval(() => requestRenderFn?.(), 500);
+	} else if (ACTIVE <= 0 && TICK) {
+		clearInterval(TICK);
+		TICK = null;
+	}
+}
+
+export function spinIcon(): string {
+	return FRAMES[Math.floor(Date.now() / 150) % FRAMES.length];
+}
+
+export class Lines {
+	private get: (width: number) => string[];
+	constructor(get: (width: number) => string[]) {
+		this.get = get;
+	}
+	render(width: number): string[] {
+		return this.get(width);
+	}
+	invalidate(): void {}
+}
+const EMPTY = new Lines(() => []);
+
+const shortPath = (p: string): string => {
+	const home = homedir();
+	return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+};
+
+const textOf = (r: TResult): string =>
+	r.content.filter((c) => c.type === "text").map((c) => c.text ?? "").join("\n").trim();
+
+const firstLine = (s: string): string => s.split("\n").find((l) => l.trim()) ?? "";
+
+// Summary = first line with content. Punctuation-only lines (e.g. a lone `{` from
+// pretty-printed MCP JSON) explain nothing -> take the next one.
+const firstMeaningful = (s: string): string => {
+	const lines = s.split("\n").filter((l) => l.trim());
+	return lines.find((l) => !/^[\s{}\[\],;:]+$/.test(l)) ?? lines[0] ?? "";
+};
+
+const countLines = (s: string): number => (s ? s.split("\n").filter(Boolean).length : 0);
+
+// Tint folder paths / URLs; everything else default.
+export const LINK_RE = /(?:https?:\/\/[^\s"'`)}\]]+|(?:~|\.{1,2})?\/[\w.+@~%/-]+|[\w.+@~-]+(?:\/[\w.+@~%/-]+)+)/g;
+export function paintLinks(text: string, tint: (s: string) => string): string {
+	return text.replace(LINK_RE, (m) => tint(m));
+}
+
+// "tint" only exists in arnative themes; other themes fall back to accent (probed per render)
+const tintOf = (theme: Theme): ((s: string) => string) => {
+	try {
+		theme.fg("tint", "");
+		return (s) => theme.fg("tint", s);
+	} catch {
+		return (s) => theme.fg("accent", s);
+	}
+};
+
+// Word-limited smart title: `maxWords` words + ellipsis; full text when expanded.
+export function smartTitle(cmd: string, maxWords = 6): string {
+	const words = cmd.replace(/\r?\n/g, " ").trim().split(/\s+/).filter(Boolean);
+	if (words.length <= maxWords) return words.join(" ");
+	return `${words.slice(0, maxWords).join(" ")}…`;
+}
+
+// Result line prefix: 󱞩 dim (duration lives at the right end of the title).
+export function resHead(theme: Theme): string {
+	return theme.fg("dim", "󱞩");
+}
+
+// Title line: duration right-aligned and space-aware (title truncated when it
+// doesn't fit); expanded = full title wrapped. All lines stay <= inner (overflow bug).
+export function titleRow(
+	theme: Theme,
+	icon: string,
+	name: string,
+	argPart: string,
+	inner: number,
+	dur: string,
+	expanded: boolean,
+): string[] {
+	const head = `${icon} ${name} ${argPart}`.trim();
+	const durStr = dur ? theme.fg("dim", dur) : "";
+	if (!durStr) {
+		return expanded ? wrapTextWithAnsi(head, inner) : [truncateToWidth(head, inner, "…")];
+	}
+	const durW = visibleWidth(durStr);
+	const avail = Math.max(8, inner - durW);
+	const wrapW = Math.max(4, avail - 1); // minimal 1 spasi sebelum durasi
+	const lines = expanded ? wrapTextWithAnsi(head, wrapW) : [truncateToWidth(head, wrapW, "…")];
+	const pad = Math.max(1, avail - visibleWidth(lines[0]));
+	lines[0] = `${lines[0]}${" ".repeat(pad)}${durStr}`;
+	return lines;
+}
+
+// Default summary: collapsed `󱞩 first output line`, empty when expanded (the
+// full output is right below — no duplicate first line).
+export const resText: Res = (r, th, tint, isErr, expanded) => {
+	if (expanded && !isErr) return "";
+	const f = firstLine(textOf(r));
+	return f ? `${resHead(th)} ${paintLinks(f, tint)}` : resHead(th);
+};
+
+// Numeric summary `󱞩 → N matches`; errors fall back to the first line (most important).
+export const numRes =
+	(fmt: (n: number) => string): Res =>
+	(r, th, tint, isErr, expanded) => {
+		if (isErr) return resText(r, th, tint, isErr, false);
+		if (expanded) return "";
+		return `${resHead(th)} ${fmt(countLines(textOf(r)))}`;
+	};
+
+// First markdown heading in the text (e.g. `## omaga-sync workflow (2026-08-23)`).
+const firstHeading = (s: unknown): string =>
+	typeof s === "string" ? (s.split("\n").find((l) => /^#{1,6}\s/.test(l.trim()))?.trim() ?? "") : "";
+
+// One-line summary for tools without their own renderer. memory_write appends the
+// heading it just wrote (from args.content) so the line names WHAT was written
+// instead of just "Appended to MEMORY.md".
+export function toolSummary(name: string, text: string, args?: any): string {
+	const head = firstMeaningful(text).trim();
+	const title = name === "memory_write" ? firstHeading(args?.content) : "";
+	return title ? `${head}. ${title}` : head;
+}
+
+// Expand hint `[ctrl+o to expand]` (key text follows the active keybinding).
+export function expandHint(th: Theme): string {
+	let key = "ctrl+o";
+	try {
+		key = keyText("app.tools.expand") || key;
+	} catch {
+		// outside a pi session: keep the literal
+	}
+	return th.fg("dim", `[${key} to expand]`);
+}
+
+// Expanded detail: themed markdown (same layout as a normal pi message — code
+// blocks, lists, colors) instead of a plain dim dump.
+export const fullText = (r: TResult, _th: Theme, width = 0): string[] => {
+	const text = textOf(r);
+	if (!text) return [];
+	if (!width) return text.split("\n").map((l) => _th.fg("dim", l));
+	try {
+		return new Markdown(text, 0, 0, getMarkdownTheme()).render(Math.max(8, width));
+	} catch {
+		return text.split("\n").map((l) => _th.fg("dim", l));
+	}
+};
+
+const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+const isBlankLine = (l: string): boolean => l.replace(ANSI_RE, "").trim() === "";
+
+// Drop blank lines at both edges (the built-in Spacer) — that's the gap between boxes.
+export function stripBlankEdges(lines: string[]): string[] {
+	let s = 0;
+	let e = lines.length;
+	while (s < e && isBlankLine(lines[s])) s++;
+	while (e > s && isBlankLine(lines[e - 1])) e--;
+	return lines.slice(s, e);
+}
+
+// The inter-box gap is the built-in Spacer(1) of ToolExecutionComponent, stripped
+// with a prototype render patch + global guard (same pattern as the footer patch).
+// ONLY lines we draw ourselves (our boxes) get stripped: third-party tools use
+// their own "self" shell too, so the marker is a name list (filled by minimal() +
+// BOXED_TOOLS) rather than the shell. Without that bound their lines would lose
+// the Spacer + Box padding and stick to the neighbour.
+const OWN_BOX = new Set<string>();
+const hasOwnRendererDef = (self: { toolDefinition?: { renderCall?: unknown; renderResult?: unknown } }): boolean =>
+	Boolean(self?.toolDefinition?.renderCall || self?.toolDefinition?.renderResult);
+
+const GAP_KEY = Symbol.for("pi-arnative.toolGapStripped");
+if (ToolExecutionComponent?.prototype?.render && !(globalThis as Record<symbol, boolean>)[GAP_KEY]) {
+	(globalThis as Record<symbol, boolean>)[GAP_KEY] = true;
+	const origRender = ToolExecutionComponent.prototype.render;
+	ToolExecutionComponent.prototype.render = function (width: number): string[] {
+		const lines = origRender.call(this, width);
+		const name = (this as { toolName?: string }).toolName ?? "";
+		return OWN_BOX.has(name) || !hasOwnRendererDef(this) ? stripBlankEdges(lines) : lines;
+	};
+}
+
+// --- Tools without their own renderer: same box, one-line summary ---
+// Without this pi renders them as a plain bg block (name + 10 output lines).
+// Our renderer is installed through the prototype (same pattern as the gap patch)
+// only for tools that define no renderCall/renderResult of their own (our own
+// tools and pi-web-access etc. are untouched).
+//
+// Exceptions: the pi-web-access tools that look different from our box
+// (`web_search`, `fetch_content`, `get_search_content`; that package hardcodes
+// their display names as "search "/"fetch "/"get_content "). Their renderer
+// content is used as-is and only wrapped in our box. `source_check` is
+// deliberately NOT boxed: its partial phase (curator: URLs + approval state)
+// would disappear because our partial path returns nothing.
+// The `todo` tool (@juicesharp/rpiv-todo) is boxed with a check-square icon
+// (\uf14a) and the toolPendingBg/toolSuccessBg theme backgrounds.
+const BOXED_TOOLS = new Map([
+	["web_search", "search"],
+	["fetch_content", "fetch"],
+	["get_search_content", "get_content"],
+	["todo", "todo"],
+]);
+const displayName = (name: string): string => BOXED_TOOLS.get(name) ?? name;
+for (const n of BOXED_TOOLS.keys()) OWN_BOX.add(n);
+
+// MCP tools (pi-mcp-adapter) already use the "self" shell, but we render their
+// result ourselves: their result renderer prints the WHOLE output on error
+// (unbounded, outside the box) and the JSON title+args in the call can be dozens
+// of lines. A 1-line summary + [ctrl+o to expand] is tighter; their args lines
+// still feed the call box so the invoked MCP tool stays visible.
+const MCP_TOOL = (name: string): boolean => name === "mcp" || name === "mcpScript" || name.startsWith("mcp__");
+const pakaiCallMereka = (name: string): boolean => BOXED_TOOLS.has(name) || MCP_TOOL(name);
+
+// The MCP box title names the invoked tool (full args when expanded).
+const mcpInfo = (name: string, args: any, th: Theme): string => {
+	if (!MCP_TOOL(name)) return "";
+	const tool = String(args?.tool ?? "");
+	const server = String(args?.server ?? "");
+	return tool ? th.fg("dim", `${tool}${server ? ` @ ${server}` : ""}`) : "";
+};
+
+// Cap third-party lines in the call box; the rest goes behind [ctrl+o to expand].
+const CALL_ROWS = 2;
+const capped = (th: Theme, rows: string[], expanded: boolean): string[] =>
+	expanded || rows.length <= CALL_ROWS ? rows : [...rows.slice(0, CALL_ROWS), th.fg("dim", expandHint(th))];
+
+// Lines from a third-party renderer component (right padding trimmed, ANSI kept).
+const componentLines = (component: any, width: number): string[] => {
+	try {
+		const lines = component?.render(Math.max(8, width));
+		return Array.isArray(lines) ? lines.map((l: string) => String(l).trimEnd()) : [];
+	} catch {
+		return [];
+	}
+};
+
+// Status icon + third-party lines -> our box content lines.
+const boxedRows = (icon: string, lines: string[]): string[] => {
+	const body = lines.filter((l) => !isBlankLine(l));
+	return body.length ? [`${icon} ${body[0]}`, ...body.slice(1)] : [icon];
+};
+
+/**
+ * Subtle per-tool bg (see also toolPendingBg/toolSuccessBg for `todo`).
+ * `memory_write` uses customMessageBg: thin, violet-ish = "note", just distinct
+ * from the plain progress boxes. Use `name.startsWith("memory_")` to cover all
+ * memory tools.
+ */
+export const boxBgOf = (name: string): string | undefined => (name === "memory_write" ? "customMessageBg" : undefined);
+
+const DEFAULT_TOOL_KEY = Symbol.for("pi-arnative.defaultToolBox");
+if (ToolExecutionComponent?.prototype?.render && !(globalThis as Record<symbol, boolean>)[DEFAULT_TOOL_KEY]) {
+	(globalThis as Record<symbol, boolean>)[DEFAULT_TOOL_KEY] = true;
+	const proto = ToolExecutionComponent.prototype as any;
+	const origCall = proto.getCallRenderer;
+	const origResult = proto.getResultRenderer;
+	const origShell = proto.getRenderShell;
+	const hasOwnRenderer = (self: any): boolean => Boolean(origCall.call(self) || origResult.call(self));
+
+	// A tool call with no registered definition (e.g. an unknown tool name that
+	// errored with "Tool X not found") makes hasRendererDefinition() false, so the
+	// constructor adds the plain contentText fallback and updateDisplay() never calls
+	// getCallRenderer/getResultRenderer — our patch is bypassed and the call renders
+	// as bare name + pretty-printed args. Claim those calls as defined so they take
+	// the same box path as any other renderer-less tool.
+	const origHasRendererDefinition = proto.hasRendererDefinition;
+	proto.hasRendererDefinition = function (): boolean {
+		return origHasRendererDefinition.call(this) || this.toolDefinition === undefined;
+	};
+
+	proto.getRenderShell = function (): string {
+		if (pakaiCallMereka(this.toolName)) return "self";
+		return hasOwnRenderer(this) ? origShell.call(this) : "self";
+	};
+
+	proto.getCallRenderer = function () {
+		const name: string = this.toolName;
+		const own = origCall.call(this);
+		if (own && !pakaiCallMereka(name)) return own;
+		return (args: any, th: Theme, ctx: TCtx) =>
+			new Lines((width) => {
+				if ((ctx.state as Record<string, unknown> | undefined)?.hasResult) return [];
+				const icon = th.fg("warning", spinIcon());
+				const theirs = own ? componentLines(own.call(this, args, th, ctx), width - 6) : [];
+				if (name === "todo" && theirs.length)
+					return box(th, width, formatTodoRows(theirs, th), "toolPendingBg");
+				if (pakaiCallMereka(name) && theirs.length)
+					return box(th, width, boxedRows(icon, capped(th, theirs, Boolean(this.expanded))));
+				const inner = Math.max(8, width - 4);
+				return box(th, width, titleRow(th, icon, th.fg("accent", displayName(name)), "", inner, "", false), boxBgOf(name));
+			});
+	};
+
+	proto.getResultRenderer = function () {
+		const name: string = this.toolName;
+		const own = origResult.call(this);
+		// MCP: their result renderer is deliberately skipped (unbounded error dump).
+		if (own && !pakaiCallMereka(name)) return own;
+		const boxed = BOXED_TOOLS.has(name);
+		return (result: TResult, opts: { expanded: boolean; isPartial?: boolean }, th: Theme, ctx: TCtx) => {
+			if (opts.isPartial) return EMPTY;
+			((ctx.state ??= {}) as Record<string, unknown>).hasResult = true;
+			const text = textOf(result);
+			// pi-web-access reports failure via `details.error` without throwing, so
+			// ctx.isError alone is not enough: without this the error box shows ✓.
+			const isErr = Boolean(ctx.isError || result.isError || (result.details as { error?: unknown } | undefined)?.error);
+			// Errors use our own path: pi-web-access' own error box is a box inside a
+			// box. Their renderer content is only used on success.
+			const theirs =
+				boxed && !isErr
+					? own.call(this, { content: result.content, details: result.details }, opts, th, ctx)
+					: null;
+			return new Lines((width) => {
+				const tint = tintOf(th);
+				const inner = Math.max(8, width - 4);
+				const icon = isErr ? th.fg("error", "x") : th.fg("success", "✓");
+				const boxed2 = componentLines(theirs, width - 6);
+				if (name === "todo" && boxed2.length) {
+					// todo call result (status completed / in_progress)
+					const callComp = origCall.call(this)?.call(this, ctx.args, th, ctx);
+					const callLines = componentLines(callComp, width - 6);
+					const combined = [...callLines, ...boxed2];
+					const bgType = isErr ? "toolErrorBg" : "toolSuccessBg";
+					return box(th, width, formatTodoRows(combined, th), bgType);
+				}
+				if (boxed2.length) return box(th, width, boxedRows(icon, boxed2));
+				const rows = titleRow(
+					th,
+					icon,
+					th.fg("accent", displayName(name)),
+					mcpInfo(name, ctx.args, th),
+					inner,
+					"",
+					opts.expanded,
+				);
+				const summary = toolSummary(name, text, ctx.args);
+				const more = countLines(text) > 1;
+				const hint = more && !opts.expanded ? ` ${expandHint(th)}` : "";
+				rows.push(`${resHead(th)}${summary ? ` ${paintLinks(summary, tint)}` : ""}${hint}`);
+				if (opts.expanded && more) {
+					// MCP args are gone once the call box is replaced by the result.
+					if (MCP_TOOL(name)) rows.push(th.fg("dim", `args ${JSON.stringify(ctx.args ?? {})}`));
+					rows.push(...fullText(result, th, inner));
+				}
+				return box(th, width, rows, boxBgOf(name));
+			});
+		};
+	};
+}
+
+// todo line format: \uf14a icon (success color) in the title, resHead prefix on the status line.
+const formatTodoRows = (lines: string[], th: Theme): string[] => {
+	const icon = th.fg("success", "\uf14a");
+	const head = resHead(th);
+	const out: string[] = [];
+	for (let i = 0; i < lines.length; i++) {
+		let l = lines[i];
+		if (i === 0) {
+			l = l.replace(/^(\x1b\[[0-9;]*m)*todo\b/, `${icon} todo`);
+		} else {
+			l = `${head} ${l}`;
+		}
+		out.push(l);
+	}
+	return out;
+};
+
+
+// One render path for all tools (no per-tool duplication).
+// renderCall = running box (󰔟); renderResult = final box (✓/x + right-aligned
+// duration + 󱞩 summary); state.hasResult is written by renderResult and read at
+// render() -> exactly one box, also after reload/restore. res & full are optional
+// (default: first output line / dim detail).
+function minimal(
+	pi: ExtensionAPI,
+	tool: { execute: (...a: any[]) => Promise<any> } & Record<string, unknown>,
+	name: (th: Theme, tint: (s: string) => string) => string,
+	call: (a: any, th: Theme, tint: (s: string) => string, expanded: boolean) => string,
+	res: Res = resText,
+	full: (r: TResult, th: Theme) => string[] = fullText,
+): void {
+	OWN_BOX.add(String(tool.name ?? ""));
+	pi.registerTool({
+		...tool,
+		renderShell: "self",
+		async execute(toolCallId: string, params: any, signal: any, onUpdate: any, ctx: any) {
+			const start = performance.now();
+			ACTIVE++;
+			syncTicker();
+			try {
+				return await tool.execute(toolCallId, params, signal, onUpdate, ctx);
+			} finally {
+				TIMINGS.set(toolCallId, Math.round(performance.now() - start));
+				ACTIVE--;
+				syncTicker();
+			}
+		},
+		renderCall(args: any, theme: Theme, context: TCtx) {
+			const st = (context.state ?? {}) as Record<string, unknown>;
+			return new Lines((width) => {
+				if (st.hasResult) return [];
+				const tint = tintOf(theme);
+				const inner = Math.max(8, width - 4);
+				const rows = titleRow(
+					theme,
+					theme.fg("warning", spinIcon()),
+					name(theme, tint),
+					call(args, theme, tint, false),
+					inner,
+					"",
+					false,
+				);
+				return box(theme, width, rows);
+			});
+		},
+		renderResult(
+			result: TResult,
+			{ expanded, isPartial }: { expanded: boolean; isPartial: boolean },
+			theme: Theme,
+			context: TCtx,
+		) {
+			if (isPartial) return EMPTY;
+			((context.state ??= {}) as Record<string, unknown>).hasResult = true;
+			const text = textOf(result);
+			const isErr = Boolean(context.isError || result.isError || text.startsWith("Error"));
+			const ms = context.toolCallId ? TIMINGS.get(context.toolCallId) : undefined;
+			const dur = ms !== undefined ? `${(ms / 1000).toFixed(1)}s` : "";
+			const icon = isErr ? theme.fg("error", "x") : theme.fg("success", "✓");
+			return new Lines((width) => {
+				const tint = tintOf(theme);
+				const inner = Math.max(8, width - 4);
+				const rows = titleRow(
+					theme,
+					icon,
+					name(theme, tint),
+					call(context.args ?? {}, theme, tint, expanded),
+					inner,
+					dur,
+					expanded,
+				);
+				const resLine = res(result, theme, tint, isErr, expanded);
+				if (resLine) rows.push(resLine);
+				if (expanded) rows.push(...full(result, theme));
+				return box(theme, width, rows);
+			});
+		},
+	} as any);
+}
+
+function arnativeTools(pi: ExtensionAPI) {
+	// Re-render source for the spinner + ticker cleanup when the session closes
+	pi.on("session_start", async (_event, ctx) => {
+		requestRenderFn = () => {
+			try {
+				(ctx.ui as { requestRender?: () => void }).requestRender?.();
+			} catch {
+				// ignore
+			}
+		};
+	});
+	pi.on("session_shutdown", async () => {
+		if (TICK) {
+			clearInterval(TICK);
+			TICK = null;
+		}
+		requestRenderFn = null;
+	});
+
+	// Gap is only stripped for our own boxes (see OWN_BOX above).
+
+	// bash: `󰔟 $ <6 words>…` / `✓ $ <full title when expanded>  0.1s`
+	minimal(
+		pi,
+		createBashTool(cwd),
+		(th) => th.fg("accent", "$"),
+		(a, _th, tint, expanded) => {
+			const cmd = (a.command ?? "").replace(/\r?\n/g, " ").trim();
+			return paintLinks(expanded ? cmd : smartTitle(cmd), tint);
+		},
+	);
+
+	// read: `read path[:range]` → `󱞩 N lines`
+	minimal(
+		pi,
+		createReadTool(cwd),
+		(th) => th.fg("accent", "read"),
+		(a, _th, tint) => {
+			const range =
+				a.offset || a.limit ? `:${a.offset ?? 1}${a.limit ? `-${(a.offset ?? 1) + a.limit - 1}` : ""}` : "";
+			return `${tint(shortPath(a.path ?? ""))}${range}`;
+		},
+		numRes((n) => `${n} lines`),
+	);
+
+	// grep: `grep /pattern/ in path (glob)` → `󱞩 → N matches`
+	minimal(
+		pi,
+		createGrepTool(cwd),
+		(th) => th.fg("accent", "grep"),
+		(a, _th, tint) =>
+			`/${a.pattern ?? ""}/ in ${tint(shortPath(a.path ?? "."))}${a.glob ? ` (${a.glob})` : ""}`,
+		numRes((n) => `→ ${n} matches`),
+	);
+
+	// find: `find pattern in path` → `󱞩 → N files`
+	minimal(
+		pi,
+		createFindTool(cwd),
+		(th) => th.fg("accent", "find"),
+		(a, _th, tint) => `${a.pattern ?? ""} in ${tint(shortPath(a.path ?? "."))}`,
+		numRes((n) => `→ ${n} files`),
+	);
+
+	// write: `write path`, default res (first output line)
+	minimal(
+		pi,
+		createWriteTool(cwd),
+		(th) => th.fg("accent", "write"),
+		(a, _th, tint) => tint(shortPath(a.path ?? "")),
+	);
+
+	// edit: `edit path`, `󱞩 +N / -M`, expand = diff toolDiff*
+	minimal(
+		pi,
+		createEditTool(cwd),
+		(th) => th.fg("accent", "edit"),
+		(a, _th, tint) => tint(shortPath(a.path ?? "")),
+		(r, th, _tint, isErr, expanded) => {
+			if (isErr) return resText(r, th, (s) => s, isErr, false);
+			const diff: string = r.details?.diff ?? "";
+			let add = 0;
+			let del = 0;
+			for (const l of diff.split("\n")) {
+				if (l.startsWith("+") && !l.startsWith("+++")) add++;
+				else if (l.startsWith("-") && !l.startsWith("---")) del++;
+			}
+			return `${resHead(th)} ${th.fg("toolDiffAdded", `+${add}`)} / ${th.fg("toolDiffRemoved", `-${del}`)}`;
+		},
+		(r, th) => {
+			const diff: string = r.details?.diff ?? "";
+			if (!diff) return fullText(r, th);
+			return diff.split("\n").map((l) =>
+				l.startsWith("+") && !l.startsWith("+++")
+					? th.fg("toolDiffAdded", l)
+					: l.startsWith("-") && !l.startsWith("---")
+						? th.fg("toolDiffRemoved", l)
+						: th.fg("toolDiffContext", l),
+			);
+		},
+	);
+}
+
+export default arnativeTools;
+
+// Self-check: `node extensions/tools.ts`.
+const isMain = process.argv[1] && import.meta.url.endsWith(process.argv[1].split("\\").join("/"));
+if (isMain) {
+	const assert = (cond: boolean, msg: string) => {
+		if (!cond) {
+			console.error(`FAIL: ${msg}`);
+			process.exit(1);
+		}
+	};
+	const mark = (s: string) => `<${s}>`;
+	const th: Theme = { fg: (_c, s) => s };
+	const R = { content: [{ type: "text", text: "path:1:match a\npath:2:match b\npath:3:match c" }] };
+
+	assert(smartTitle("echo hi") === "echo hi", "teks pendek utuh");
+	assert(smartTitle("ls a b c d e f g h") === "ls a b c d e…", "potong di batas 6 kata");
+	assert(smartTitle("a b c d e f g") === "a b c d e f…", "7 kata -> 6 kata + elipsis");
+	assert(smartTitle("a b c d e f") === "a b c d e f", "6 kata utuh");
+
+	assert(paintLinks("cd /run/media/x && echo hi", mark) === "cd </run/media/x> && echo hi", "filter path absolut");
+	assert(paintLinks("git clone https://github.com/a/b", mark) === "git clone <https://github.com/a/b>", "filter link URL");
+	assert(paintLinks("ls extensions/tools.ts", mark) === "ls <extensions/tools.ts>", "filter path relatif");
+	assert(paintLinks("echo plain 2>&1", mark) === "echo plain 2>&1", "teks polos tak tersentuh");
+
+	// right-aligned duration, space-aware (overflow bug regression)
+	const t1 = titleRow(th, "✓", "$", "echo hi", 30, "0.1s", false);
+	assert(t1.length === 1 && visibleWidth(t1[0]) === 30, "durasi rata kanan pas selebar inner");
+	assert(t1[0].endsWith("0.1s"), "durasi di ujung kanan judul");
+	const t2 = titleRow(th, "✓", "$", "word ".repeat(40), 30, "0.1s", false);
+	assert(t2.length === 1 && visibleWidth(t2[0]) === 30, "collapsed: judul panjang tetap 1 baris pas");
+	const t3 = titleRow(th, "✓", "$", "word ".repeat(40), 30, "0.1s", true);
+	assert(t3.every((l) => visibleWidth(l) <= 30), "expanded: semua baris <= inner");
+	const t4 = titleRow(th, "✓", "$", "echo hi", 30, "", false);
+	assert(!t4[0].includes("0.1s"), "tanpa durasi: kosong (restore sesi lama)");
+
+	// no duplicate summary
+	assert(resText(R, th, (s) => s, false, true) === "", "expand: ringkasan kosong");
+	assert(resText(R, th, (s) => s, false, false) === "󱞩 path:1:match a", "collapsed: baris pertama tampil");
+	assert(numRes((n) => `→ ${n} matches`)(R, th, (s) => s, false, false) === "󱞩 → 3 matches", "grep: N matches");
+	assert(
+		numRes((n) => `→ ${n} matches`)({ content: [{ type: "text", text: "Error: bad" }] }, th, (s) => s, true, false) ===
+			"󱞩 Error: bad",
+		"error: jatuh ke baris pertama",
+	);
+
+	// inter-box gap stripped
+	assert(stripBlankEdges(["", "a", "", "b", "  ", ""]).join() === "a,,b", "baris kosong tepi dibuang");
+	assert(stripBlankEdges(["", "\x1b[2m\x1b[22m", "x"]).join() === "x", "baris ANSI kosong = blank");
+	assert(stripBlankEdges(["a"]).join() === "a", "tanpa blank tetap utuh");
+
+	// tools without their own renderer -> same box (memory_write etc.)
+	const noRenderer = { toolName: "memory_write", toolDefinition: {} };
+	// tool with no definition (e.g. "Tool glob not found") -> still a box, not plain text
+	const noDefinition = { toolName: "glob", toolDefinition: undefined, expanded: false };
+	assert(
+		ToolExecutionComponent.prototype.hasRendererDefinition.call(noDefinition) === true &&
+			ToolExecutionComponent.prototype.getRenderShell.call(noDefinition) === "self",
+		"tool tanpa definisi: shell self (kotak kita, bukan fallback polos)",
+	);
+	assert(
+		ToolExecutionComponent.prototype.hasRendererDefinition.call({ toolName: "x", toolDefinition: {} }) === true,
+		"tool dengan definisi tetap punya renderer",
+	);
+	const noDefOut = (ToolExecutionComponent.prototype.getResultRenderer.call(noDefinition) as any)(
+		{ content: [{ type: "text", text: '{\n  "pattern": "**/*.ts"\n}\nTool glob not found' }] },
+		{ expanded: false, isPartial: false },
+		th,
+		{ args: { pattern: "**/*.ts" }, state: {} },
+	).render(60);
+	assert(noDefOut[0].startsWith("\u256d") && noDefOut[noDefOut.length - 1].startsWith("\u2570"), "tool tanpa definisi: hasil dibungkus kotak");
+	assert(
+		noDefOut.some((l: string) => l.includes("\u2713 glob")) &&
+			noDefOut.some((l: string) => l.includes('[ctrl+o to expand]')),
+		"tool tanpa definisi: judul + ringkasan + expand hint",
+	);
+	const withRenderer = { toolName: "bash", toolDefinition: { renderResult: () => undefined } };
+	assert(ToolExecutionComponent.prototype.getRenderShell.call(noRenderer) === "self", "tool polos -> shell self");
+	assert(
+		ToolExecutionComponent.prototype.getRenderShell.call(withRenderer) === "default",
+		"tool ber-renderer -> shell aslinya (tak disentuh)",
+	);
+	assert(
+		toolSummary("memory_write", "Appended to MEMORY.md\n\nExisting MEMORY.md preview (1 lines)", {
+			content: "## omaga-sync workflow (2026-08-23)\n- Repo: /x",
+		}) === "Appended to MEMORY.md. ## omaga-sync workflow (2026-08-23)",
+		"memory_write: ringkasan + judul seksi yang baru ditulis",
+	);
+	assert(
+		toolSummary("memory_write", "Appended to daily log: /x/y.md", { content: "- catatan tanpa judul" }) ===
+			"Appended to daily log: /x/y.md",
+		"memory_write daily: tanpa judul tetap baris pertama",
+	);
+	assert(toolSummary("todo", "line1\nline2") === "line1", "tool lain: baris pertama saja");
+	assert(
+		toolSummary("mcp", '{\n  "url": "https://example.com",\n  "ok": true\n}') === '"url": "https://example.com",',
+		"baris pertama hanya '{' -> ringkasan baris berikutnya (JSON MCP)",
+	);
+	assert(
+		toolSummary("mcp", '{\n  "url": "https://example.com",\n  "ok": true\n}', {}) === '"url": "https://example.com",' &&
+			toolSummary("mcp", "{") === "{",
+		"ringkasan JSON: pakai baris berisi, fallback ke baris pertama",
+	);
+	assert(toolSummary("memory_write", "Appended to MEMORY.md") === "Appended to MEMORY.md", "ballast: ringkasan biasa utuh");
+
+	// distinct subtle bg: memory_write only
+	assert(boxBgOf("memory_write") === "customMessageBg", "memory_write -> bg customMessageBg");
+	assert(boxBgOf("bash") === undefined && boxBgOf("todo") === undefined, "tool lain tanpa bg tambahan");
+	const bgSeen: string[] = [];
+	const thBgMem: Theme = { fg: (_c, s) => s, bg: (c, s) => (bgSeen.push(c), `<${s}>`) };
+	const bgLines = box(thBgMem, 20, ["memory_write  0.1s", "󱞩 Appended to MEMORY.md"], boxBgOf("memory_write"));
+	assert(bgSeen.length === bgLines.length && bgSeen.every((c) => c === "customMessageBg"), "bg dipakai di semua baris kotak");
+	assert(bgLines.every((l) => visibleWidth(l.replace(/[<>]/g, "")) === 20), "bg tidak merusak lebar baris kotak");
+	assert(bgLines[0]!.replace(/[<>]/g, "").startsWith("╭"), "garis atas tetap utuh");
+
+	// pi-web-access web_search/fetch_content/get_search_content: isi renderer mereka, kotak kita
+	const paResult: any = { render: () => ["\x1b[32mPi Coding Agent\x1b[39m (77 matches, 77 shown)"] };
+	const paCall: any = { render: () => ["\x1b[1mget_content \x1b[22m\x1b[36mfind 4\x1b[39m"] };
+	const boxedRes = {
+		toolName: "get_search_content",
+		toolDefinition: { renderCall: () => paCall, renderResult: () => paResult },
+	};
+	assert(
+		ToolExecutionComponent.prototype.getRenderShell.call(boxedRes) === "self",
+		"pi-web-access: shell dipaksa self (ikut kotak kita, bukan blok bg)",
+	);
+	const searchRes = {
+		toolName: "web_search",
+		toolDefinition: { renderCall: () => ({ render: () => ["\x1b[1msearch \x1b[22m\x1b[36m\"site:pi.dev\"\x1b[39m"] }), renderResult: () => ({ render: () => ["\x1b[32m5 sources\x1b[39m"] }) },
+	};
+	assert(
+		ToolExecutionComponent.prototype.getRenderShell.call(searchRes) === "self",
+		"web_search: shell dipaksa self (ikut kotak kita)",
+	);
+	const bRes = ToolExecutionComponent.prototype.getResultRenderer.call(boxedRes) as any;
+	const bOut = bRes(
+		{ content: [{ type: "text", text: "raw panjang yang tak perlu ditampilkan" }], details: { matchCount: 77 } },
+		{ expanded: false, isPartial: false },
+		th,
+		{ args: {} },
+	).render(60);
+	assert(bOut[0].startsWith("╭") && bOut[bOut.length - 1].startsWith("╰"), "pi-web-access: hasil dibungkus kotak kita");
+	assert(bOut.some((l: string) => l.includes("(77 matches, 77 shown)")), "pi-web-access: info renderer mereka dipertahankan");
+	assert(!bOut.some((l: string) => l.includes("raw panjang")), "pi-web-access: teks mentah tidak dipakai saat renderer ada");
+	assert(
+		bRes(
+			{
+				content: [{ type: "text", text: "No URL specified. Provide url, urlIndex, or query." }],
+				details: { error: "No URL specified" },
+			},
+			{ expanded: false, isPartial: false },
+			th,
+			{ args: {} },
+		)
+			.render(60)
+			.some((l: string) => l.includes("x get_content")),
+		"pi-web-access: details.error -> ikon x (bukan ✓)",
+	);
+	const bErr = bRes(
+		{ content: [{ type: "text", text: "No URL specified. Provide url, urlIndex, or query." }] },
+		{ expanded: false, isPartial: false },
+		th,
+		{ args: {}, isError: true },
+	).render(60);
+	assert(
+		bErr.some((l: string) => l.includes("No URL specified")) &&
+			bErr.filter((l: string) => l.includes("╭")).length === 1,
+		"error: satu kotak saja (tanpa kotak bersarang)",
+	);
+	assert(
+		bRes({ content: [{ type: "text", text: "x" }] }, { expanded: false, isPartial: true }, th, { args: {} }).render(60)
+			.length === 0,
+		"pi-web-access: fase partial kosong (tanpa kotak ganda)",
+	);
+	const bCall = ToolExecutionComponent.prototype.getCallRenderer.call(boxedRes) as any;
+	const bCallOut = bCall({}, th, { args: {}, state: {} }).render(60);
+	assert(
+		bCallOut[0].startsWith("╭") && bCallOut.some((l: string) => l.includes("find 4")),
+		"pi-web-access: baris args renderer mereka masuk kotak",
+	);
+
+	// Guard: source_check is deliberately NOT boxed — its curator partial carries
+	// URLs + approval state, while our partial path returns nothing. Without this
+	// assert a later edit of BOXED_TOOLS would swallow it silently.
+	for (const n of ["source_check"]) {
+		const theirs = () => "renderer-mereka";
+		assert(
+			ToolExecutionComponent.prototype.getResultRenderer.call({ toolName: n, toolDefinition: { renderResult: theirs } })() ===
+				"renderer-mereka",
+			`${n}: sengaja tidak dipaksa kotak (partial kurator butuh URL)`,
+		);
+	}
+
+	// pi-mcp-adapter: result does NOT use their renderer (unbounded error dump)
+	// -> 1-line summary + [ctrl+o to expand]; the invoked tool stays visible.
+	const mcpTheirs = () => "renderer-mcp";
+	const mcpTool = { toolName: "mcp", toolDefinition: { renderCall: mcpTheirs, renderResult: mcpTheirs } };
+	assert(
+		(ToolExecutionComponent.prototype.getResultRenderer.call(mcpTool) as any) !== mcpTheirs,
+		"mcp: renderer hasil pihak ketiga dilewati (dump error dibatasi)",
+	);
+	assert(
+		(ToolExecutionComponent.prototype.getResultRenderer.call({ toolName: "mcp__tinyfish", toolDefinition: { renderResult: mcpTheirs } }) as any) !==
+			mcpTheirs,
+		"mcp__<server>: renderer mereka dilewati (jalur kotak kita)",
+	);
+	const mcpPayload = {
+		content: [{ type: "text", text: "x Failed to call tool\nu Expected parameters:\n{\n  \"required\": []\n}" }],
+		details: { error: "failed" },
+	};
+	const mcpOut = (ToolExecutionComponent.prototype.getResultRenderer.call(mcpTool) as any)(
+		mcpPayload,
+		{ expanded: false, isPartial: false },
+		th,
+		{ args: { tool: "fetch_content", server: "tinyfish" }, state: {} },
+	).render(96);
+	assert(mcpOut.length <= 6, `mcp error collapsed tetap pendek (${mcpOut.length} baris)`);
+	assert(
+		mcpOut.some((l: string) => l.includes("fetch_content @ tinyfish")),
+		"mcp: judul menyebut tool MCP yang dipanggil",
+	);
+	assert(mcpOut.some((l: string) => l.includes("[ctrl+o to expand]")), "mcp: ada petunjuk expand");
+	const mcpFull = (ToolExecutionComponent.prototype.getResultRenderer.call(mcpTool) as any)(
+		mcpPayload,
+		{ expanded: true, isPartial: false },
+		th,
+		{ args: { tool: "fetch_content", server: "tinyfish" }, state: {} },
+	).render(96);
+	assert(mcpFull.length > mcpOut.length, "mcp: expand menampilkan dump + args lengkap");
+
+	// Gap is only stripped for our own box lines.
+	// The default export registers the tools (filling OWN_BOX); a pi stub suffices.
+	arnativeTools({
+		registerTool: () => {},
+		on: () => {},
+		registerShortcut: () => {},
+		registerMessageRenderer: () => {},
+	} as never);
+	assert(
+		OWN_BOX.has("bash") && OWN_BOX.has("read") && OWN_BOX.has("edit") && OWN_BOX.has("fetch_content") && OWN_BOX.has("web_search"),
+		"OWN_BOX: tool kotak kita + tool boxed terdaftar",
+	);
+	assert(!OWN_BOX.has("mcp") && !OWN_BOX.has("source_check"), "OWN_BOX: renderer pihak lain tidak dirapatkan");
+	assert(hasOwnRendererDef(mcpTool) && !hasOwnRendererDef(noRenderer), "patokan rapat: definisi renderer tool");
+	assert(
+		capped(th, ["a", "b", "c"], false).length === CALL_ROWS + 1 &&
+			capped(th, ["a", "b", "c"], true).length === 3 &&
+			capped(th, ["a"], false).length === 1,
+		"baris call pihak ketiga dibatasi hanya saat collapsed",
+	);
+	assert(
+		mcpInfo("bash", { tool: "x" }, th) === "" && mcpInfo("mcp", { tool: "x", server: "s" }, th).includes("x @ s"),
+		"mcpInfo hanya untuk tool MCP",
+	);
+
+	const ctxState: TCtx = { args: { content: "## Judul\n- x" }, state: {} };
+	const resRenderer = ToolExecutionComponent.prototype.getResultRenderer.call(noRenderer) as any;
+	const out = resRenderer(
+		{ content: [{ type: "text", text: "Appended to MEMORY.md\n\nExisting MEMORY.md preview" }] },
+		{ expanded: false, isPartial: false },
+		th,
+		ctxState,
+	).render(60);
+	assert(out[0].startsWith("╭") && out[out.length - 1].startsWith("╰"), "hasil tool polos dibungkus kotak");
+	assert(
+		out.some((l: string) => l.includes("Appended to MEMORY.md. ## Judul")),
+		"kotak memuat ringkasan + judul",
+	);
+	assert(out.some((l: string) => l.includes("[ctrl+o to expand]")), "collapsed: ada petunjuk expand");
+	assert(
+		resRenderer(
+			{ content: [{ type: "text", text: "Appended to MEMORY.md\n\nExisting preview" }] },
+			{ expanded: true, isPartial: false },
+			th,
+			ctxState,
+		).render(60).length > out.length,
+		"expand: detail lengkap ikut tampil",
+	);
+
+	// stale 󰔟 box regression (restore-safe)
+	const st: Record<string, unknown> = {};
+	const comp = new Lines(() => (st.hasResult ? [] : ["row"]));
+	assert(comp.render(10).length === 1, "running: kotak 󰔟 tampil");
+	st.hasResult = true;
+	assert(comp.render(10).length === 0, "final: kotak running hilang (restore-safe)");
+	assert(FRAMES.includes(spinIcon()), "ikon animasi selalu frame valid");
+	ACTIVE = 3;
+	syncTicker();
+	assert(TICK !== null, "ticker hidup selama ada tool berjalan");
+	ACTIVE = 0;
+	syncTicker();
+	assert(TICK === null, "ticker mati saat idle (tanpa leak timer)");
+
+	// todo render: \uf14a + 2 lines (title & status) + background box
+	const todoCall = () => ({ render: () => ["todo → Test subject"] });
+	const todoResult = () => ({ render: () => ["● completed"] });
+	const todoTool = { toolName: "todo", toolDefinition: { renderCall: todoCall, renderResult: todoResult } };
+	const thBgTodo: Theme = {
+		fg: (_c, s) => s,
+		bg: (c, s) => `[bg:${c}]${s}[/bg]`,
+	};
+	const todoCallOut = (ToolExecutionComponent.prototype.getCallRenderer.call(todoTool) as any)({}, thBgTodo, { state: {} }).render(60);
+	assert(todoCallOut[0].includes("[bg:toolPendingBg]"), "todo call: background pending");
+	assert(todoCallOut.some((l: string) => l.includes("\uf14a todo → Test subject")), "todo call: ikon \uf14a di judul");
+
+	const todoResultOut = (ToolExecutionComponent.prototype.getResultRenderer.call(todoTool) as any)(
+		{ content: [] },
+		{ expanded: false, isPartial: false },
+		thBgTodo,
+		{ state: {}, args: {} },
+	).render(60);
+	assert(todoResultOut[0].includes("[bg:toolSuccessBg]"), "todo result: background success");
+	assert(todoResultOut.some((l: string) => l.includes("\uf14a todo → Test subject")), "todo result: ikon \uf14a di baris 1");
+	assert(todoResultOut.some((l: string) => l.includes("● completed")), "todo result: status dengan prefix resHead di baris 2");
+
+	// Expanded detail: themed markdown, error text intact and no longer plain dim.
+	const errDetail = fullText(
+		{ content: [{ type: "text", text: '{\n  "pattern": "**/*.ts"\n}\nTool glob not found' }], isError: true },
+		th,
+		40,
+	);
+	const plain = errDetail.join("\n").replace(/\x1b\[[0-9;]*m/g, "");
+	assert(plain.includes("Tool glob not found") && plain.includes('"pattern"'), "detail error: isi utuh");
+	assert(
+		errDetail.every((l: string) => visibleWidth(l) === 40),
+		"detail error: dirender markdown (di-wrap + dipad ke lebar), bukan split baris polos",
+	);
+	assert(
+		fullText({ content: [{ type: "text", text: "a\nb" }] }, th, 0).join("|") === th.fg("dim", "a") + "|" + th.fg("dim", "b"),
+		"tanpa width (self-check) tetap dump dim",
+	);
+	console.log("OK");
+}