@hheei/pi-ext-ui 0.0.0-stage → 0.1.0

package/dist/renderer.js

@@ -0,0 +1,1274 @@
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { applyPatchGlyph } from "./apply-patch-glyph.js";
+import { previewV4aOperations } from "./apply-patch-preview.js";
+import { applyPatchFacts, formatApplyPatchOperationRow, } from "./apply-patch-view.js";
+import { DiffView, diffStats } from "./diff-view.js";
+import { ToolView, } from "./tool-view.js";
+/** Tools with a pi-ext-ui-owned renderer. Other tools stay on Pi's renderer. */
+export const SPECIALIZED_TOOL_RENDERERS = [
+    "edit",
+    "write",
+    "apply_patch",
+    "python_eval",
+    "codemode",
+];
+/** Web-access tools use the shared folding shell while retaining their native body renderer. */
+export const WEB_ACCESS_TOOLS = ["web_search", "web_fetch", "web_open"];
+const APPLY_PATCH_TOOL_NAME = "apply_patch";
+const APPLY_PATCH_PREVIEW_STATE_KEY = "__piExtUiApplyPatchPreview";
+const PYTHON_EVAL_TOOL_NAME = "python_eval";
+const PYTHON_EVAL_TOOL_TITLE = "python_eval";
+const PYTHON_EVAL_DETAILS_FORMAT = "pi-ext-tools-python-eval";
+const EDIT_TOOL_NAME = "edit";
+const WRITE_TOOL_NAME = "write";
+const EDIT_VIEW_KEY = "__piExtToolsEditView";
+const WRITE_VIEW_KEY = "__piExtToolsWriteView";
+const SPECIALIZED_TOOL_SET = new Set(SPECIALIZED_TOOL_RENDERERS);
+const WEB_ACCESS_TOOL_SET = new Set(WEB_ACCESS_TOOLS);
+const CALL_VIEW_STATE_KEY = "__piExtUiCallView";
+const CODEMODE_OPTIONS_PREFIX = "// @options:";
+const CODEMODE_SCRIPT_HEADER = /^Script (?:completed|failed)\r?\nWall time ([\d.]+) seconds\r?\nOutput:\r?\n/;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function estimateStreamingTokens(args) {
+    if (args === undefined || args === null)
+        return 0;
+    try {
+        const serialized = typeof args === "string" ? args : JSON.stringify(args);
+        if (!serialized || serialized === "{}")
+            return 0;
+        return Math.max(1, Math.ceil(serialized.length / 4));
+    }
+    catch {
+        return 0;
+    }
+}
+function formatDurationMs(ms) {
+    if (ms === undefined || !Number.isFinite(ms))
+        return "";
+    return ms < 1000 ? `${String(Math.round(ms))}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+function formatCostUsd(cost) {
+    if (cost === undefined || !Number.isFinite(cost) || cost <= 0)
+        return "";
+    return `$${cost >= 0.01 ? cost.toFixed(2) : cost.toPrecision(2)}`;
+}
+export function extractCodemodeHeaderFacts(args) {
+    if (!isRecord(args))
+        return "";
+    const options = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (key !== "code" && value !== undefined && value !== null) {
+            options[key] = value;
+        }
+    }
+    if (typeof args.code === "string") {
+        const firstLine = args.code.split(/\r?\n/, 1)[0]?.trim() ?? "";
+        if (firstLine.startsWith(CODEMODE_OPTIONS_PREFIX)) {
+            try {
+                const parsed = JSON.parse(firstLine.slice(CODEMODE_OPTIONS_PREFIX.length).trim());
+                if (isRecord(parsed)) {
+                    Object.assign(options, parsed);
+                }
+            }
+            catch { }
+        }
+    }
+    const facts = [];
+    const timeoutMs = typeof options.timeout_ms === "number"
+        ? options.timeout_ms
+        : typeof options.timeout === "number"
+            ? options.timeout * 1000
+            : undefined;
+    if (timeoutMs !== undefined) {
+        const label = timeoutMs >= 1000 ? `${String(Math.round(timeoutMs / 1000))}s` : `${String(timeoutMs)}ms`;
+        facts.push(`(timeout ${label})`);
+    }
+    if (typeof options.max_output_tokens === "number") {
+        facts.push(`(tokens ${String(options.max_output_tokens)})`);
+    }
+    if (typeof options.target === "string" && options.target !== "local") {
+        facts.push(`(${options.target})`);
+    }
+    return facts.join(" ");
+}
+function extractSummaryArg(toolName, args) {
+    if (toolName === "codemode") {
+        return extractCodemodeHeaderFacts(args);
+    }
+    if (!isRecord(args))
+        return "";
+    for (const key of [
+        "query",
+        "queries",
+        "url",
+        "urls",
+        "source",
+        "claim",
+        "id",
+        "search_id",
+        "topic",
+        "path",
+        "pattern",
+    ]) {
+        const val = args[key];
+        if (typeof val === "string" && val.trim() !== "") {
+            return stripTerminalSequences(val.trim());
+        }
+        if (Array.isArray(val) && val.length > 0 && typeof val[0] === "string") {
+            const first = stripTerminalSequences(val[0].trim());
+            return val.length > 1 ? `${first} (+${String(val.length - 1)})` : first;
+        }
+    }
+    return "";
+}
+function extractHeavyInputCommand(toolName, args) {
+    if (!isRecord(args))
+        return undefined;
+    if (toolName === "bash" && typeof args.command === "string") {
+        return args.command.trim();
+    }
+    if (toolName === "python_eval" && typeof args.code === "string") {
+        return args.code.trim();
+    }
+    if (toolName === "codemode" && typeof args.code === "string") {
+        return args.code.trim();
+    }
+    return undefined;
+}
+function extractNestedCalls(result) {
+    if (result === undefined || !isRecord(result.details))
+        return [];
+    const rawList = Array.isArray(result.details.calls)
+        ? result.details.calls
+        : Array.isArray(result.details.nestedCalls)
+            ? result.details.nestedCalls
+            : undefined;
+    if (rawList === undefined)
+        return [];
+    const items = [];
+    for (const entry of rawList) {
+        if (!isRecord(entry))
+            continue;
+        const name = typeof entry.name === "string"
+            ? entry.name
+            : typeof entry.toolName === "string"
+                ? entry.toolName
+                : undefined;
+        if (name === undefined)
+            continue;
+        const rawStatus = entry.status;
+        const status = rawStatus === "running" ||
+            rawStatus === "ok" ||
+            rawStatus === "error" ||
+            rawStatus === "cancelled"
+            ? rawStatus
+            : undefined;
+        const summary = typeof entry.args === "string" && entry.args.trim() !== ""
+            ? entry.args
+            : typeof entry.summary === "string"
+                ? entry.summary
+                : undefined;
+        items.push({
+            toolName: name,
+            summary,
+            status,
+            isError: entry.isError === true || status === "error",
+            isWarning: entry.isWarning === true || status === "cancelled",
+            durationMs: typeof entry.durationMs === "number" ? entry.durationMs : undefined,
+            cost: typeof entry.cost === "number" ? entry.cost : undefined,
+            error: typeof entry.error === "string" ? entry.error : undefined,
+        });
+    }
+    return items;
+}
+function extractResultText(toolName, result) {
+    const parts = [];
+    for (const block of result.content) {
+        if (block.type === "text" && block.text.trim() !== "") {
+            parts.push(stripTerminalSequences(block.text));
+        }
+    }
+    const joined = parts.join("\n");
+    if (toolName === "codemode") {
+        const match = CODEMODE_SCRIPT_HEADER.exec(joined);
+        const wallTimeSeconds = match?.[1] !== undefined ? Number.parseFloat(match[1]) : undefined;
+        const cleaned = joined.replace(CODEMODE_SCRIPT_HEADER, "").trim();
+        return { outputText: cleaned, wallTimeSeconds };
+    }
+    return { outputText: joined, wallTimeSeconds: undefined };
+}
+function callStatsParts(total, failCount) {
+    if (failCount > 0) {
+        return [`${String(total - failCount)} ok`, `${String(failCount)} failed`];
+    }
+    return [`${String(total)} ${total === 1 ? "call" : "calls"}`];
+}
+function resolveContainerStatus(params) {
+    if (params.selfFailed)
+        return "error";
+    if (params.hasChildren)
+        return "none";
+    if (params.isPartial)
+        return "running";
+    return params.isError ? "error" : "ok";
+}
+function createInputCodeSection(toolName, args, theme) {
+    const raw = extractHeavyInputCommand(toolName, args);
+    if (raw === undefined || raw === "")
+        return undefined;
+    const isShell = toolName === "bash";
+    const lines = raw
+        .replace(/\r/g, "")
+        .replace(/\t/g, "  ")
+        .split("\n")
+        .map((line, i) => theme.fg("mdCode", isShell ? (i === 0 ? `$ ${line}` : `  ${line}`) : line));
+    return { railToken: "muted", content: lines };
+}
+function formatArgsPreview(args) {
+    if (args === undefined || args === null)
+        return "";
+    if (typeof args === "string")
+        return stripTerminalSequences(args);
+    try {
+        return JSON.stringify(args, null, 2);
+    }
+    catch {
+        return "";
+    }
+}
+function nestedStatusGlyph(status, theme) {
+    switch (status) {
+        case "streaming":
+            return theme.fg("muted", "⋯");
+        case "running":
+            return theme.fg("accent", "◐");
+        case "ok":
+            return theme.fg("success", "✓");
+        case "warn":
+            return theme.fg("warning", "!");
+        case "error":
+            return theme.fg("error", "✗");
+        case "none":
+            return "";
+    }
+}
+/**
+ * The host stacks a tool execution's call and result views. Following the
+ * official edit renderer, the call view is stored in the shared renderer
+ * state so the result renderer can hide it in place within the same
+ * updateDisplay pass — no draw-time flags needed.
+ */
+function rememberCallView(context, view, toolName) {
+    if (isRecord(context.state)) {
+        context.state[CALL_VIEW_STATE_KEY] = view;
+    }
+    // A container tool's own row yields as soon as execution starts: nested rows and output
+    // carry the progress, so a spinner row on top would only duplicate them.
+    if ((toolName === "codemode" ||
+        toolName === PYTHON_EVAL_TOOL_NAME ||
+        toolName === APPLY_PATCH_TOOL_NAME) &&
+        context.executionStarted) {
+        view.hide();
+    }
+}
+function hideCallView(context, toolName, isPartial) {
+    if (toolName !== "codemode" &&
+        toolName !== PYTHON_EVAL_TOOL_NAME &&
+        toolName !== APPLY_PATCH_TOOL_NAME &&
+        isPartial)
+        return;
+    const view = isRecord(context.state) ? context.state[CALL_VIEW_STATE_KEY] : undefined;
+    if (view instanceof ToolView)
+        view.hide();
+}
+function toolPath(args) {
+    let value = args;
+    if (typeof value === "string") {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return "";
+        }
+    }
+    if (!isRecord(value))
+        return "";
+    return typeof value.path === "string" ? value.path.trim() : "";
+}
+function editPath(args) {
+    return toolPath(args);
+}
+function numericField(value, key) {
+    return isRecord(value) && typeof value[key] === "number" ? value[key] : undefined;
+}
+function writeStoredDiff(lines) {
+    const hunks = [];
+    let hunk = [];
+    const finish = () => {
+        if (hunk.length > 0)
+            hunks.push(hunk);
+        hunk = [];
+    };
+    for (const entry of lines) {
+        if (!isRecord(entry))
+            return undefined;
+        if (entry.type === "sep") {
+            finish();
+            continue;
+        }
+        if (entry.type !== "add" && entry.type !== "del" && entry.type !== "ctx")
+            return undefined;
+        if (typeof entry.content !== "string")
+            return undefined;
+        const line = entry.type === "del" ? entry.oldNum : entry.newNum;
+        if (typeof line !== "number")
+            return undefined;
+        hunk.push({ kind: entry.type, line, text: entry.content });
+    }
+    finish();
+    return hunks.length === 0
+        ? undefined
+        : { kind: "hunks", hunks: hunks.map((lines) => ({ lines })) };
+}
+/** Uses only the baseline and content already stored by the write tool. */
+function writePresentation(args, details) {
+    const view = isRecord(details) ? details[WRITE_VIEW_KEY] : undefined;
+    if (!isRecord(view))
+        return undefined;
+    if (view.kind === "noChange")
+        return { kind: "noChange" };
+    if (view.kind === "diff") {
+        const stored = Array.isArray(view.lines) ? writeStoredDiff(view.lines) : undefined;
+        if (stored === undefined)
+            return undefined;
+        const source = stored;
+        const stats = diffStats(source);
+        return stats === undefined
+            ? undefined
+            : {
+                kind: "diff",
+                source,
+                added: numericField(view, "added") ?? stats.added,
+                removed: numericField(view, "removed") ?? stats.removed,
+            };
+    }
+    if (view.kind !== "new" && view.kind !== "replace")
+        return undefined;
+    const content = typeof view.content === "string"
+        ? view.content
+        : isRecord(args) && typeof args.content === "string"
+            ? args.content
+            : undefined;
+    if (content === undefined)
+        return undefined;
+    const lines = numericField(view, "lines") ?? content.split("\n").length;
+    return {
+        kind: "content",
+        label: view.kind === "new" ? `new file (${String(lines)} lines)` : `wrote (${String(lines)} lines)`,
+        content,
+    };
+}
+function fileToolPresentation(toolName, args, details, isError) {
+    const path = toolPath(args);
+    if (toolName === "read") {
+        if (path === "")
+            return undefined;
+        return { summary: `read ${path}`, status: isError ? "error" : "ok" };
+    }
+    if (toolName === WRITE_TOOL_NAME) {
+        const presentation = isError ? undefined : writePresentation(args, details);
+        const delta = presentation?.kind === "diff"
+            ? ` (+${String(presentation.added)} -${String(presentation.removed)})`
+            : presentation?.kind === "content"
+                ? ` (${presentation.label})`
+                : presentation?.kind === "noChange"
+                    ? " (no changes)"
+                    : "";
+        if (path === "" && delta === "")
+            return undefined;
+        return {
+            summary: `${WRITE_TOOL_NAME} ${path}${delta}`.trim(),
+            status: isError ? "error" : presentation?.kind === "noChange" ? "none" : "ok",
+        };
+    }
+    return undefined;
+}
+/** Pi native edit persists a unified patch plus the same change as a numbered display diff. */
+function editDiffSource(details) {
+    if (!isRecord(details))
+        return undefined;
+    if (typeof details.patch === "string" && details.patch.trim() !== "") {
+        return { kind: "unifiedPatch", text: details.patch };
+    }
+    if (typeof details.diff === "string" && details.diff.trim() !== "") {
+        return displayDiffSource(details.diff);
+    }
+    return editViewSource(details[EDIT_VIEW_KEY]);
+}
+function displayDiffSource(diff) {
+    const hunks = [];
+    let current = [];
+    let pendingBreak = false;
+    for (const raw of diff.split(/\r?\n/)) {
+        if (raw === "")
+            continue;
+        const sign = raw.charAt(0);
+        const match = /^ *(\d+)? ?(.*)$/.exec(raw.slice(1));
+        const lineNumber = match?.[1];
+        if (lineNumber === undefined) {
+            pendingBreak = true;
+            continue;
+        }
+        if (pendingBreak && current.length > 0) {
+            hunks.push(current);
+            current = [];
+        }
+        pendingBreak = false;
+        const kind = sign === "+" ? "add" : sign === "-" ? "del" : "ctx";
+        current.push({ kind, line: Number(lineNumber), text: match?.[2] ?? "" });
+    }
+    if (current.length === 0)
+        return undefined;
+    hunks.push(current);
+    return { kind: "hunks", hunks: hunks.map((lines) => ({ lines })) };
+}
+function editViewSource(view) {
+    const hunks = editViewHunks(view);
+    return hunks.length === 0 ? undefined : { kind: "hunks", hunks };
+}
+function editViewHunks(view) {
+    if (!isRecord(view))
+        return [];
+    const ops = view.kind === "single" && isRecord(view.op)
+        ? [view.op]
+        : view.kind === "multi" && Array.isArray(view.ops)
+            ? view.ops.filter(isRecord)
+            : [];
+    return ops.flatMap((op) => hunksForEditOp(op));
+}
+function hunksForEditOp(op) {
+    if (typeof op.oldContent !== "string" || typeof op.newContent !== "string")
+        return [];
+    const startLine = typeof op.startLine === "number" && op.startLine > 0 ? op.startLine : 1;
+    return lineHunks(op.oldContent.replace(/\r\n/g, "\n"), op.newContent.replace(/\r\n/g, "\n"), startLine);
+}
+function splitFragment(text) {
+    if (text === "")
+        return [];
+    const lines = text.split("\n");
+    if (lines.at(-1) === "")
+        lines.pop();
+    return lines;
+}
+/** Line LCS of one stored before/after fragment. No file context is invented. */
+function lineHunks(before, after, startLine) {
+    const oldLines = splitFragment(before);
+    const newLines = splitFragment(after);
+    const oldCount = oldLines.length;
+    const newCount = newLines.length;
+    const lengths = Array.from({ length: oldCount + 1 }, () => Array(newCount + 1).fill(0));
+    for (let oldIndex = oldCount - 1; oldIndex >= 0; oldIndex -= 1) {
+        const row = lengths[oldIndex];
+        const next = lengths[oldIndex + 1];
+        if (row === undefined || next === undefined)
+            continue;
+        for (let newIndex = newCount - 1; newIndex >= 0; newIndex -= 1) {
+            row[newIndex] =
+                oldLines[oldIndex] === newLines[newIndex]
+                    ? (next[newIndex + 1] ?? 0) + 1
+                    : Math.max(next[newIndex] ?? 0, row[newIndex + 1] ?? 0);
+        }
+    }
+    const lines = [];
+    let oldIndex = 0;
+    let newIndex = 0;
+    let oldLine = startLine;
+    let newLine = startLine;
+    while (oldIndex < oldCount || newIndex < newCount) {
+        const row = lengths[oldIndex];
+        const next = lengths[oldIndex + 1];
+        if (oldIndex < oldCount && newIndex < newCount && oldLines[oldIndex] === newLines[newIndex]) {
+            lines.push({ kind: "ctx", line: newLine, text: oldLines[oldIndex] ?? "" });
+            oldIndex += 1;
+            newIndex += 1;
+            oldLine += 1;
+            newLine += 1;
+        }
+        else if (newIndex < newCount &&
+            (oldIndex === oldCount || (row?.[newIndex + 1] ?? 0) > (next?.[newIndex] ?? 0))) {
+            lines.push({ kind: "add", line: newLine, text: newLines[newIndex] ?? "" });
+            newIndex += 1;
+            newLine += 1;
+        }
+        else {
+            lines.push({ kind: "del", line: oldLine, text: oldLines[oldIndex] ?? "" });
+            oldIndex += 1;
+            oldLine += 1;
+        }
+    }
+    const changed = lines.some((line) => line.kind !== "ctx");
+    return changed ? [{ lines }] : [];
+}
+function patchTextForCopy(details) {
+    if (isRecord(details) && typeof details.patch === "string")
+        return details.patch;
+    const hunks = editViewHunks(isRecord(details) ? details[EDIT_VIEW_KEY] : undefined);
+    if (hunks.length === 0)
+        return undefined;
+    return (hunks
+        .map((hunk) => {
+        let oldStart = 0;
+        let newStart = 0;
+        let oldCount = 0;
+        let newCount = 0;
+        const body = hunk.lines.map((line) => {
+            if (line.kind !== "add") {
+                oldCount += 1;
+                if (oldStart === 0)
+                    oldStart = line.line;
+            }
+            if (line.kind !== "del") {
+                newCount += 1;
+                if (newStart === 0)
+                    newStart = line.line;
+            }
+            const sign = line.kind === "add" ? "+" : line.kind === "del" ? "-" : " ";
+            return sign + line.text;
+        });
+        if (body.length === 0)
+            return "";
+        const header = "@@ -" +
+            String(oldStart || 1) +
+            "," +
+            String(oldCount) +
+            " +" +
+            String(newStart || 1) +
+            "," +
+            String(newCount) +
+            " @@";
+        return [header, ...body].join("\n");
+    })
+        .filter((hunk) => hunk !== "")
+        .join("\n") || undefined);
+}
+/**
+ * One compact nested summary for a file tool. Reports the delta only when the
+ * caller actually has result details; a codemode nested record keeps arguments
+ * alone, so it degrades to `<tool> <path>` instead of inventing counts.
+ */
+export function inlinePresentation(toolName, args, details, isError) {
+    const fileTool = fileToolPresentation(toolName, args, details, isError);
+    if (fileTool !== undefined)
+        return fileTool;
+    if (toolName !== EDIT_TOOL_NAME)
+        return undefined;
+    const path = editPath(args);
+    const source = isError ? undefined : editDiffSource(details);
+    const stats = source === undefined ? undefined : diffStats(source);
+    if (path === "" && stats === undefined)
+        return undefined;
+    const label = path === "" ? EDIT_TOOL_NAME : `${EDIT_TOOL_NAME} ${path}`;
+    return {
+        summary: stats === undefined ? label : `${label} (+${String(stats.added)} -${String(stats.removed)})`,
+        status: isError ? "error" : "ok",
+    };
+}
+function formatNestedCallRow(call, theme) {
+    const inline = inlinePresentation(call.toolName, call.summary, undefined, call.isError === true);
+    const status = call.status === "running"
+        ? "running"
+        : call.isWarning === true
+            ? "warn"
+            : (inline?.status ?? (call.isError === true ? "error" : "ok"));
+    const glyph = nestedStatusGlyph(status, theme);
+    const name = theme.fg("toolTitle", inline?.summary ?? call.toolName);
+    const cleanArgs = inline !== undefined || call.summary === undefined
+        ? ""
+        : stripTerminalSequences(call.summary.trim());
+    const truncatedArgs = cleanArgs.length > 72 ? `${cleanArgs.slice(0, 69)}…` : cleanArgs;
+    const summaryPart = truncatedArgs !== "" ? ` ${theme.fg("muted", truncatedArgs)}` : "";
+    const durText = formatDurationMs(call.durationMs);
+    const durationPart = durText !== "" ? ` ${theme.fg("dim", durText)}` : "";
+    const costText = formatCostUsd(call.cost);
+    const costPart = costText !== "" ? ` ${theme.fg("dim", costText)}` : "";
+    return `${glyph} ${name}${summaryPart}${durationPart}${costPart}`;
+}
+function renderEditResult(params) {
+    const { theme, context, result, renderOptions, defaultLevel, options } = params;
+    const path = editPath(context.args);
+    const isError = context.isError || result.isError;
+    const source = isError ? undefined : editDiffSource(result.details);
+    const stats = source === undefined ? undefined : diffStats(source);
+    const summaryParts = [
+        stats === undefined ? path : `${path} (+${String(stats.added)} -${String(stats.removed)})`,
+    ];
+    const durText = formatDurationMs(context.durationMs);
+    if (durText !== "")
+        summaryParts.push(durText);
+    const summary = summaryParts.join(" · ");
+    const output = stripTerminalSequences(extractResultText(EDIT_TOOL_NAME, result).outputText);
+    const patch = patchTextForCopy(result.details);
+    // A successful edit hides the top-level check mark; the diff body carries the change.
+    const status = isError
+        ? "error"
+        : renderOptions.isPartial
+            ? "running"
+            : source !== undefined
+                ? "none"
+                : "ok";
+    const sections = source === undefined
+        ? output === ""
+            ? []
+            : [{ railToken: isError ? "error" : "dim", content: output }]
+        : [{ railToken: "dim", content: new DiffView({ theme, source }) }];
+    const copy = patch !== undefined ? { primary: patch } : output !== "" ? { primary: output } : undefined;
+    return new ToolView({
+        theme,
+        header: { title: EDIT_TOOL_NAME, status, summary },
+        sections,
+        copy,
+        outputPad: context.outputPad,
+        stateHolder: context.state,
+        defaultLevel,
+        globalExpanded: renderOptions.expanded,
+        invalidate: () => context.invalidate(),
+        copyToClipboard: options?.copyToClipboard,
+    });
+}
+function renderWriteResult(params) {
+    const { theme, context, result, renderOptions, defaultLevel, options } = params;
+    const path = toolPath(context.args);
+    const isError = context.isError || result.isError;
+    const presentation = isError ? undefined : writePresentation(context.args, result.details);
+    const output = stripTerminalSequences(extractResultText(WRITE_TOOL_NAME, result).outputText);
+    const baseSummary = presentation?.kind === "diff"
+        ? `${path} (+${String(presentation.added)} -${String(presentation.removed)})`
+        : presentation?.kind === "content"
+            ? `${path} (${presentation.label})`
+            : presentation?.kind === "noChange"
+                ? `${path} (no changes)`
+                : path;
+    const durText = formatDurationMs(context.durationMs);
+    const summaryParts = [baseSummary];
+    if (durText !== "")
+        summaryParts.push(durText);
+    const summary = summaryParts.join(" · ");
+    const sections = presentation?.kind === "diff"
+        ? [{ railToken: "dim", content: new DiffView({ theme, source: presentation.source }) }]
+        : presentation?.kind === "content"
+            ? [{ railToken: "dim", content: presentation.content }]
+            : output === ""
+                ? []
+                : [{ railToken: isError ? "error" : "dim", content: output }];
+    const copyText = presentation?.kind === "content"
+        ? presentation.content
+        : presentation?.kind === "diff"
+            ? undefined
+            : output;
+    return new ToolView({
+        theme,
+        header: {
+            title: WRITE_TOOL_NAME,
+            status: isError
+                ? "error"
+                : renderOptions.isPartial
+                    ? "running"
+                    : presentation?.kind === "diff"
+                        ? "none"
+                        : presentation?.kind === "noChange"
+                            ? "none"
+                            : "ok",
+            summary,
+        },
+        sections,
+        copy: copyText !== undefined && copyText !== "" ? { primary: copyText } : undefined,
+        outputPad: context.outputPad,
+        stateHolder: context.state,
+        defaultLevel,
+        globalExpanded: renderOptions.expanded,
+        invalidate: () => context.invalidate(),
+        copyToClipboard: options?.copyToClipboard,
+    });
+}
+/** Reads only the persisted `pi-ext-tools-eval` details; other shapes degrade to plain output. */
+function pythonEvalFacts(details) {
+    if (!isRecord(details) || details.format !== PYTHON_EVAL_DETAILS_FORMAT)
+        return undefined;
+    const rawRows = Array.isArray(details.rows) ? details.rows : [];
+    const rows = [];
+    for (const entry of rawRows) {
+        if (!isRecord(entry))
+            continue;
+        if (entry.kind === "text" && typeof entry.text === "string") {
+            rows.push({ kind: "text", text: entry.text });
+        }
+        else if (entry.kind === "display" && typeof entry.text === "string") {
+            rows.push({ kind: "display", text: entry.text });
+        }
+        else if (entry.kind === "result" && typeof entry.text === "string") {
+            rows.push({ kind: "result", text: entry.text });
+        }
+        else if (entry.kind === "tool" && isRecord(entry.trace)) {
+            const trace = entry.trace;
+            if (typeof trace.name !== "string")
+                continue;
+            rows.push({
+                kind: "tool",
+                name: trace.name,
+                args: trace.args,
+                durationMs: typeof trace.durationMs === "number" ? trace.durationMs : undefined,
+                error: typeof trace.error === "string" ? trace.error : undefined,
+            });
+        }
+    }
+    return {
+        rows,
+        error: typeof details.error === "string" ? details.error : undefined,
+    };
+}
+/** A nested file-tool row keeps its tool name; other tools degrade to name plus bounded args. */
+function formatEvalToolRow(row, theme) {
+    const isError = row.error !== undefined;
+    const inline = inlinePresentation(row.name, row.args, undefined, isError);
+    const glyph = nestedStatusGlyph(isError ? "error" : "ok", theme);
+    if (inline !== undefined) {
+        const durText = formatDurationMs(row.durationMs);
+        const durationPart = durText !== "" ? ` ${theme.fg("dim", durText)}` : "";
+        return `${glyph} ${theme.fg("toolTitle", inline.summary)}${durationPart}`;
+    }
+    const summary = typeof row.args === "string" && row.args.trim() !== ""
+        ? stripTerminalSequences(row.args.trim())
+        : "";
+    const truncated = summary.length > 72 ? `${summary.slice(0, 69)}…` : summary;
+    const summaryPart = truncated !== "" ? ` ${theme.fg("muted", truncated)}` : "";
+    return `${glyph} ${theme.fg("toolTitle", row.name)}${summaryPart}`;
+}
+function renderPythonEvalResult(params) {
+    const { theme, context, result, renderOptions, defaultLevel, options } = params;
+    const facts = pythonEvalFacts(result.details);
+    const isError = (context.isError ?? false) || (result.isError ?? false);
+    const toolRows = facts?.rows.filter((row) => row.kind === "tool") ??
+        [];
+    const anyToolError = toolRows.some((row) => row.error !== undefined);
+    const failed = isError || facts?.error !== undefined || anyToolError;
+    const status = resolveContainerStatus({
+        isError,
+        isPartial: renderOptions.isPartial === true,
+        hasChildren: toolRows.length > 0,
+        selfFailed: failed && !anyToolError,
+    });
+    const parts = [];
+    if (isRecord(context.args)) {
+        if (context.args.reset === true)
+            parts.push("(reset)");
+        if (typeof context.args.timeout === "number")
+            parts.push(`(timeout ${String(context.args.timeout)}s)`);
+    }
+    if (facts !== undefined) {
+        if (toolRows.length > 0) {
+            const failCount = toolRows.filter((row) => row.error !== undefined).length;
+            parts.push(...callStatsParts(toolRows.length, failCount));
+        }
+        else if (facts.rows.length > 0) {
+            parts.push(`${String(facts.rows.length)} ${facts.rows.length === 1 ? "row" : "rows"}`);
+        }
+    }
+    const durText = formatDurationMs(context.durationMs);
+    if (durText !== "")
+        parts.push(durText);
+    const summary = parts.join(" · ");
+    const collapsedRows = toolRows.length > 0 ? toolRows.map((row) => formatEvalToolRow(row, theme)) : undefined;
+    const code = extractHeavyInputCommand(PYTHON_EVAL_TOOL_NAME, context.args);
+    const inputSection = createInputCodeSection(PYTHON_EVAL_TOOL_NAME, context.args, theme);
+    const sections = inputSection !== undefined ? [inputSection] : [];
+    if (facts !== undefined) {
+        const outputRows = [];
+        for (const row of facts.rows) {
+            if (row.kind === "tool") {
+                outputRows.push(formatEvalToolRow(row, theme));
+            }
+            else if (row.kind === "display" || row.kind === "result") {
+                const prefix = theme.fg("dim", `${row.kind}:`);
+                const lines = row.text.replace(/\r/g, "").split("\n");
+                for (let i = 0; i < lines.length; i++) {
+                    outputRows.push(i === 0 ? `${prefix} ${lines[i]}` : `  ${lines[i]}`);
+                }
+            }
+            else if (row.text !== "") {
+                outputRows.push(...row.text.replace(/\r/g, "").split("\n"));
+            }
+        }
+        if (outputRows.length > 0) {
+            sections.push({
+                railToken: isError ? "error" : "dim",
+                content: outputRows,
+            });
+        }
+    }
+    else {
+        const output = stripTerminalSequences(extractResultText(PYTHON_EVAL_TOOL_NAME, result).outputText);
+        if (output !== "") {
+            sections.push({ railToken: isError ? "error" : "dim", content: output });
+        }
+    }
+    const output = stripTerminalSequences(extractResultText(PYTHON_EVAL_TOOL_NAME, result).outputText);
+    const copy = code !== undefined && code !== ""
+        ? { primary: code, full: output !== "" ? `${code}\n---\n${output}` : code }
+        : output !== ""
+            ? { primary: output }
+            : undefined;
+    return new ToolView({
+        theme,
+        header: {
+            title: PYTHON_EVAL_TOOL_TITLE,
+            status,
+            summary,
+        },
+        collapsedRows,
+        sections,
+        copy,
+        outputPad: context.outputPad,
+        stateHolder: context.state,
+        defaultLevel,
+        globalExpanded: renderOptions.expanded,
+        invalidate: () => context.invalidate(),
+        copyToClipboard: options?.copyToClipboard,
+    });
+}
+/**
+ * Streaming call view: operation headers recognized from the patch prefix
+ * preview as pending rows. `󰄰` only marks a recognized header — it promises
+ * neither validation nor application.
+ */
+function renderApplyPatchCallView(params) {
+    const { theme, context, defaultLevel, options } = params;
+    const patch = isRecord(context.args) && typeof context.args.patch === "string" ? context.args.patch : "";
+    const host = isRecord(context.args) &&
+        typeof context.args.target === "string" &&
+        context.args.target !== "local"
+        ? context.args.target
+        : undefined;
+    // The preview cursor lives in the shared render state so each streamed update
+    // only processes new lines; an absent state degrades to a one-shot preview.
+    const state = isRecord(context.state) ? context.state : undefined;
+    const cursor = state?.[APPLY_PATCH_PREVIEW_STATE_KEY];
+    const stored = typeof cursor === "object" && cursor !== null ? cursor : undefined;
+    const operations = previewV4aOperations(patch, context.argsComplete === true, stored);
+    if (state !== undefined && stored !== undefined) {
+        state[APPLY_PATCH_PREVIEW_STATE_KEY] = stored;
+    }
+    const files = new Set(operations.map((operation) => operation.path)).size;
+    const summary = files > 0 ? `${String(files)} ${files === 1 ? "file" : "files"}` : "";
+    const rows = operations.map((operation) => formatApplyPatchOperationRow({
+        operationIndex: 0,
+        kind: operation.kind,
+        path: operation.path,
+        addedLines: operation.addedLines,
+        removedLines: operation.removedLines,
+        status: "pending",
+        appliedHunks: undefined,
+        totalHunks: undefined,
+        partialReason: undefined,
+    }, theme, host));
+    return new ToolView({
+        theme,
+        header: {
+            title: APPLY_PATCH_TOOL_NAME,
+            status: context.isError ? "error" : "none",
+            summary,
+        },
+        collapsedRows: rows,
+        sections: [{ railToken: "dim", content: rows }],
+        copy: patch !== "" ? { primary: patch } : undefined,
+        outputPad: context.outputPad,
+        stateHolder: context.state,
+        defaultLevel,
+        globalExpanded: context.expanded,
+        invalidate: () => context.invalidate(),
+        copyToClipboard: options?.copyToClipboard,
+    });
+}
+function renderApplyPatchResultView(params) {
+    const { theme, context, result, renderOptions, defaultLevel, options } = params;
+    const facts = applyPatchFacts(result.details);
+    const isError = context.isError || result.isError;
+    const host = facts?.target;
+    // The aggregated status is the executor's fact; success hides the top glyph.
+    const status = facts === undefined
+        ? isError
+            ? "error"
+            : renderOptions.isPartial
+                ? "running"
+                : "ok"
+        : facts.status === "failed"
+            ? "error"
+            : facts.status === "partial"
+                ? "warn"
+                : "none";
+    const output = stripTerminalSequences(extractResultText(APPLY_PATCH_TOOL_NAME, result).outputText);
+    const parts = [];
+    if (facts !== undefined) {
+        const files = facts.operations.length;
+        if (files > 0)
+            parts.push(`${String(files)} ${files === 1 ? "file" : "files"}`);
+        if (facts.addedLines > 0 || facts.removedLines > 0)
+            parts.push(`+${String(facts.addedLines)} -${String(facts.removedLines)}`);
+    }
+    const durText = formatDurationMs(context.durationMs);
+    if (durText !== "")
+        parts.push(durText);
+    const summary = parts.join(" · ");
+    const rows = facts === undefined
+        ? []
+        : facts.operations.map((operation) => formatApplyPatchOperationRow(operation, theme, host));
+    const sections = rows.length > 0 ? [{ railToken: "dim", content: rows }] : [];
+    if (facts === undefined && output !== "") {
+        sections.push({ railToken: isError ? "error" : "dim", content: output });
+    }
+    else if (facts !== undefined) {
+        for (const snapshot of facts.snapshots) {
+            const hunks = snapshotHunks(snapshot);
+            if (hunks !== undefined && hunks.length > 0) {
+                sections.push({
+                    railToken: "dim",
+                    content: new DiffView({ theme, source: { kind: "hunks", hunks } }),
+                });
+            }
+        }
+        const diagnosis = (entries, glyphStatus) => entries.flatMap((entry) => [
+            `${applyPatchGlyph(glyphStatus, theme)} ${entry.paths[0] ?? "<unknown>"} · ${entry.error}`,
+            ...entry.diagnostics.map((diagnostic) => `${applyPatchGlyph(glyphStatus, theme)} ${entry.paths[0] ?? "<unknown>"} · ${diagnostic.text}`),
+        ]);
+        const failureRows = [
+            ...diagnosis(facts.rejected, "rejected"),
+            ...diagnosis(facts.unconfirmed, "unconfirmed"),
+            ...diagnosis(facts.notApplied, "not_applied"),
+        ];
+        if (failureRows.length > 0) {
+            sections.push({ railToken: "error", content: failureRows });
+        }
+    }
+    const patch = isRecord(context.args) && typeof context.args.patch === "string" ? context.args.patch : "";
+    const copy = patch !== ""
+        ? { primary: patch, full: output !== "" ? `${patch}\n---\n${output}` : patch }
+        : output !== ""
+            ? { primary: output }
+            : undefined;
+    return new ToolView({
+        theme,
+        header: { title: APPLY_PATCH_TOOL_NAME, status, summary },
+        collapsedRows: rows.length > 0 ? rows : undefined,
+        sections,
+        copy,
+        outputPad: context.outputPad,
+        stateHolder: context.state,
+        defaultLevel,
+        globalExpanded: renderOptions.expanded,
+        invalidate: () => context.invalidate(),
+        copyToClipboard: options?.copyToClipboard,
+    });
+}
+/** Hunks of one stored before/after snapshot; no file context is invented. */
+function snapshotHunks(snapshot) {
+    if (snapshot.before.length === 0 && snapshot.after.length === 0)
+        return undefined;
+    return lineHunks(snapshot.before.join("\n"), snapshot.after.join("\n"), snapshot.startLine);
+}
+function shouldInterceptTool(toolName, options) {
+    if (options?.catchAll === true) {
+        return options.match !== undefined ? options.match(toolName) : true;
+    }
+    if (options?.match?.(toolName)) {
+        return true;
+    }
+    const toolList = options?.tools;
+    if (toolList !== undefined) {
+        return toolList.includes(toolName);
+    }
+    return SPECIALIZED_TOOL_SET.has(toolName) || WEB_ACCESS_TOOL_SET.has(toolName);
+}
+function renderSpecializedResult(params) {
+    const { toolName } = params;
+    if (toolName === EDIT_TOOL_NAME)
+        return renderEditResult(params);
+    if (toolName === WRITE_TOOL_NAME)
+        return renderWriteResult(params);
+    if (toolName === PYTHON_EVAL_TOOL_NAME)
+        return renderPythonEvalResult(params);
+    if (toolName === APPLY_PATCH_TOOL_NAME)
+        return renderApplyPatchResultView(params);
+    return undefined;
+}
+function renderGenericResult(params) {
+    const { toolName, theme, context, result, renderOptions, defaultLevel, originalRenderCall, originalRenderResult, options, } = params;
+    const heavyCmd = extractHeavyInputCommand(toolName, context.args);
+    const nestedCalls = extractNestedCalls(result);
+    const isMetaTool = toolName === "codemode" || toolName === "subagent" || nestedCalls.length > 0;
+    const { outputText: rawOutput, wallTimeSeconds } = extractResultText(toolName, result);
+    const isError = (context.isError ?? false) || (result.isError ?? false);
+    const status = toolName === "codemode"
+        ? nestedCalls.length === 0 && isError
+            ? "error"
+            : "none"
+        : isMetaTool
+            ? resolveContainerStatus({
+                isError,
+                isPartial: renderOptions.isPartial === true,
+                hasChildren: nestedCalls.length > 0,
+                selfFailed: nestedCalls.length === 0 && isError,
+            })
+            : isError
+                ? "error"
+                : renderOptions.isPartial
+                    ? "running"
+                    : "ok";
+    const summaryParts = [];
+    const argSummary = extractSummaryArg(toolName, context.args);
+    if (argSummary !== "") {
+        summaryParts.push(argSummary);
+    }
+    else if (originalRenderCall !== undefined && toolName !== "codemode") {
+        const upstreamLines = originalRenderCall(context.args, theme, context).render(120);
+        const firstLine = stripTerminalSequences(upstreamLines[0] ?? "").trim();
+        const stripped = firstLine.startsWith(toolName)
+            ? firstLine.slice(toolName.length).trim()
+            : firstLine;
+        if (stripped !== "")
+            summaryParts.push(stripped);
+    }
+    if (isMetaTool && nestedCalls.length > 0) {
+        const failCount = nestedCalls.filter((c) => c.isError || c.isWarning).length;
+        summaryParts.push(...callStatsParts(nestedCalls.length, failCount));
+    }
+    if (context.durationMs !== undefined) {
+        summaryParts.push(formatDurationMs(context.durationMs));
+    }
+    else if (wallTimeSeconds !== undefined && Number.isFinite(wallTimeSeconds)) {
+        summaryParts.push(formatDurationMs(wallTimeSeconds * 1000));
+    }
+    const totalCost = nestedCalls.reduce((sum, c) => sum + (c.cost ?? 0), 0);
+    if (totalCost > 0) {
+        summaryParts.push(formatCostUsd(totalCost));
+    }
+    const summary = summaryParts.join(" · ");
+    const collapsedRows = isMetaTool && nestedCalls.length > 0
+        ? nestedCalls.map((call) => formatNestedCallRow(call, theme))
+        : undefined;
+    const inputSection = createInputCodeSection(toolName, context.args, theme);
+    const sections = inputSection !== undefined ? [inputSection] : [];
+    const outputRailToken = isError ? "error" : renderOptions.isPartial ? "accent" : "dim";
+    if (toolName === "codemode") {
+        if (rawOutput !== "") {
+            const outputColor = isError ? "error" : "toolOutput";
+            const coloredLines = rawOutput
+                .replace(/\r/g, "")
+                .replace(/\t/g, "  ")
+                .split("\n")
+                .map((line) => theme.fg(outputColor, line));
+            sections.push({
+                railToken: outputRailToken,
+                content: coloredLines,
+            });
+        }
+    }
+    else if (originalRenderResult !== undefined) {
+        const viewProbe = new ToolView({
+            theme,
+            header: { title: toolName },
+            stateHolder: context.state,
+            defaultLevel,
+            globalExpanded: renderOptions.expanded,
+        });
+        const effectiveExpanded = viewProbe.effectiveLevel === 2;
+        const effectiveOptions = {
+            ...renderOptions,
+            expanded: effectiveExpanded,
+        };
+        const lazyUpstreamComponent = {
+            render(w) {
+                return originalRenderResult(result, effectiveOptions, theme, context).render(w);
+            },
+            invalidate() { },
+        };
+        sections.push({
+            railToken: outputRailToken,
+            content: lazyUpstreamComponent,
+            maxLines: effectiveExpanded ? Number.POSITIVE_INFINITY : 9,
+        });
+    }
+    else if (rawOutput !== "") {
+        const outputColor = isError ? "error" : "toolOutput";
+        const coloredLines = rawOutput.split("\n").map((line) => theme.fg(outputColor, line));
+        sections.push({
+            railToken: outputRailToken,
+            content: coloredLines,
+        });
+    }
+    let copy;
+    if (heavyCmd !== undefined && heavyCmd !== "") {
+        copy = {
+            primary: heavyCmd,
+            full: rawOutput !== "" ? `${heavyCmd}\n---\n${rawOutput}` : heavyCmd,
+        };
+    }
+    else if (rawOutput !== "") {
+        const argsFormatted = formatArgsPreview(context.args);
+        copy = {
+            primary: rawOutput,
+            full: argsFormatted !== "" ? `${argsFormatted}\n\n${rawOutput}` : rawOutput,
+        };
+    }
+    return new ToolView({
+        theme,
+        header: {
+            title: toolName,
+            status,
+            summary,
+        },
+        collapsedRows,
+        sections,
+        copy,
+        outputPad: context.outputPad,
+        stateHolder: context.state,
+        defaultLevel,
+        globalExpanded: renderOptions.expanded,
+        invalidate: () => context.invalidate(),
+        copyToClipboard: options?.copyToClipboard,
+    });
+}
+export function createCollapsibleToolRendererResolver(options) {
+    const defaultLevel = options?.defaultCollapsed === false ? 1 : 0;
+    return (toolName, next) => {
+        const upstream = next();
+        if (!shouldInterceptTool(toolName, options)) {
+            return upstream;
+        }
+        const originalRenderCall = upstream?.renderCall;
+        const originalRenderResult = upstream?.renderResult;
+        return {
+            renderShell: "self",
+            renderCall(args, theme, context) {
+                if (toolName === APPLY_PATCH_TOOL_NAME) {
+                    const view = renderApplyPatchCallView({
+                        theme,
+                        context: { ...context, args },
+                        defaultLevel,
+                        options,
+                    });
+                    rememberCallView(context, view, toolName);
+                    return view;
+                }
+                if (toolName === EDIT_TOOL_NAME) {
+                    const path = editPath(args);
+                    const view = new ToolView({
+                        theme,
+                        header: {
+                            title: EDIT_TOOL_NAME,
+                            status: context.isError ? "error" : "running",
+                            summary: path,
+                        },
+                        outputPad: context.outputPad,
+                        stateHolder: context.state,
+                        defaultLevel,
+                        globalExpanded: context.expanded,
+                        invalidate: () => context.invalidate(),
+                        copyToClipboard: options?.copyToClipboard,
+                    });
+                    rememberCallView(context, view, toolName);
+                    return view;
+                }
+                const isStreamingArgs = context.isPartial && !context.argsComplete;
+                const status = context.isError
+                    ? "error"
+                    : toolName === "codemode"
+                        ? "none"
+                        : isStreamingArgs
+                            ? "streaming"
+                            : "running";
+                let summary = "";
+                if (isStreamingArgs) {
+                    const tokens = estimateStreamingTokens(args);
+                    summary = tokens > 0 ? `· ${String(tokens)} tokens` : "";
+                }
+                else {
+                    summary = extractSummaryArg(toolName, args);
+                    if (summary === "" && originalRenderCall !== undefined && toolName !== "codemode") {
+                        const upstreamLines = originalRenderCall(args, theme, context).render(120);
+                        const firstLine = stripTerminalSequences(upstreamLines[0] ?? "").trim();
+                        summary = firstLine.startsWith(toolName)
+                            ? firstLine.slice(toolName.length).trim()
+                            : firstLine;
+                    }
+                }
+                const heavyCmd = extractHeavyInputCommand(toolName, args);
+                const sections = [];
+                const inputSection = createInputCodeSection(toolName, args, theme);
+                if (inputSection !== undefined) {
+                    sections.push(inputSection);
+                }
+                else {
+                    const preview = formatArgsPreview(args);
+                    if (preview !== "" && preview !== "{}") {
+                        sections.push({
+                            railToken: "muted",
+                            content: preview,
+                        });
+                    }
+                }
+                const copy = heavyCmd !== undefined && heavyCmd !== ""
+                    ? { primary: heavyCmd }
+                    : formatArgsPreview(args) !== ""
+                        ? { primary: formatArgsPreview(args) }
+                        : undefined;
+                const view = new ToolView({
+                    theme,
+                    header: {
+                        title: toolName,
+                        status,
+                        summary,
+                    },
+                    sections,
+                    copy,
+                    outputPad: context.outputPad,
+                    stateHolder: context.state,
+                    defaultLevel,
+                    globalExpanded: context.expanded,
+                    invalidate: () => context.invalidate(),
+                    copyToClipboard: options?.copyToClipboard,
+                });
+                rememberCallView(context, view, toolName);
+                return view;
+            },
+            renderResult(result, renderOptions, theme, context) {
+                hideCallView(context, toolName, renderOptions.isPartial);
+                const specialized = renderSpecializedResult({
+                    toolName,
+                    theme,
+                    context,
+                    result,
+                    renderOptions,
+                    defaultLevel,
+                    options,
+                });
+                if (specialized !== undefined)
+                    return specialized;
+                return renderGenericResult({
+                    toolName,
+                    theme,
+                    context,
+                    result,
+                    renderOptions,
+                    defaultLevel,
+                    originalRenderCall,
+                    originalRenderResult,
+                    options,
+                });
+            },
+        };
+    };
+}
+export function registerCollapsibleToolRenderer(pi, options) {
+    pi.registerToolRenderer(createCollapsibleToolRendererResolver(options));
+}