@bubblebrain-ai/bubble 0.0.7 → 0.0.8

package/dist/tui-ink/approval/approval-dialog.d.ts

@@ -0,0 +1,13 @@
+import type { ApprovalDecision, ApprovalRequest } from "../../approval/types.js";
+interface ApprovalDialogProps {
+    request: ApprovalRequest;
+    onDecision: (decision: ApprovalDecision) => void;
+    /**
+     * Selecting "Yes, and don't ask again for <prefix>" calls this with the
+     * (possibly user-edited) prefix so the harness can register it in the
+     * session-scoped bash allowlist.
+     */
+    onAllowBashPrefix?: (prefix: string) => void;
+}
+export declare function ApprovalDialog({ request, onDecision, onAllowBashPrefix, }: ApprovalDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/tui-ink/approval/approval-dialog.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { theme } from "../theme.js";
+import { ApprovalSelect } from "./select.js";
+import { DiffView } from "./diff-view.js";
+import { inferBashPrefix } from "../../approval/session-cache.js";
+import { classifyBashDanger } from "../../approval/danger.js";
+export function ApprovalDialog({ request, onDecision, onAllowBashPrefix, }) {
+    const options = buildOptions(request);
+    const onSubmit = (id, extras) => {
+        switch (id) {
+            case "yes":
+                onDecision({ action: "approve", feedback: extras.feedback });
+                return;
+            case "yes-bash-prefix": {
+                const prefix = (extras.editedValue ?? "").trim();
+                if (prefix)
+                    onAllowBashPrefix?.(prefix);
+                onDecision({ action: "approve" });
+                return;
+            }
+            case "no":
+            default:
+                onDecision({ action: "reject", feedback: extras.feedback });
+                return;
+        }
+    };
+    const onCancel = () => onDecision({ action: "reject" });
+    const title = dialogTitle(request);
+    const question = dialogQuestion(request);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.accent, paddingX: 1, marginY: 1, children: [_jsx(Text, { color: theme.accent, bold: true, children: title }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsx(RequestPreview, { request: request }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: question }) }), _jsx(Box, { marginTop: 1, children: _jsx(ApprovalSelect, { options: options, onSubmit: onSubmit, onCancel: onCancel, hint: "\u2191\u2193 choose \u00B7 Enter select \u00B7 Tab add feedback \u00B7 Esc reject" }) })] }));
+}
+function buildOptions(request) {
+    if (request.type === "bash") {
+        const prefix = inferBashPrefix(request.command);
+        return [
+            { id: "yes", label: "Yes", allowAmend: true, amendPlaceholder: "and tell Claude what to do next" },
+            {
+                id: "yes-bash-prefix",
+                label: "Yes, and don't ask again for",
+                editableValue: {
+                    initial: prefix,
+                    placeholder: "command prefix (e.g. npm run:*)",
+                },
+            },
+            {
+                id: "no",
+                label: "No",
+                description: "(tab to add feedback)",
+                allowAmend: true,
+                amendPlaceholder: "and tell Claude what to do differently",
+            },
+        ];
+    }
+    // edit / write
+    return [
+        { id: "yes", label: "Yes", allowAmend: true, amendPlaceholder: "and tell Claude what to do next" },
+        {
+            id: "no",
+            label: "No",
+            description: "(tab to add feedback)",
+            allowAmend: true,
+            amendPlaceholder: "and tell Claude what to do differently",
+        },
+    ];
+}
+function dialogTitle(req) {
+    switch (req.type) {
+        case "edit":
+            return "Edit file";
+        case "write":
+            return req.fileExists ? "Overwrite file" : "Create file";
+        case "bash":
+            return "Bash command";
+        case "lsp":
+            return "Language server operation";
+    }
+}
+function dialogQuestion(req) {
+    switch (req.type) {
+        case "edit":
+            return `Do you want to make this edit to ${basename(req.path)}?`;
+        case "write":
+            return `Do you want to ${req.fileExists ? "overwrite" : "create"} ${basename(req.path)}?`;
+        case "bash":
+            return "Do you want to proceed?";
+        case "lsp":
+            return `Do you want to run ${req.operation} on ${basename(req.path)}?`;
+    }
+}
+function basename(p) {
+    const idx = p.lastIndexOf("/");
+    return idx >= 0 ? p.slice(idx + 1) : p;
+}
+function RequestPreview({ request }) {
+    switch (request.type) {
+        case "bash":
+            return _jsx(BashPreview, { command: request.command, cwd: request.cwd });
+        case "edit":
+            return _jsx(DiffView, { diff: request.diff });
+        case "write":
+            return _jsx(WritePreview, { path: request.path, content: request.content });
+    }
+}
+function BashPreview({ command, cwd }) {
+    const danger = classifyBashDanger(command);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: "$ " }), _jsx(Text, { children: command })] }), _jsxs(Text, { color: theme.muted, children: ["cwd: ", compressHome(cwd)] }), danger && (_jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: theme.warning, bold: true, children: ["\u26A0 ", danger.pattern, ":"] }), _jsxs(Text, { color: theme.warning, children: [" ", danger.message] })] }))] }));
+}
+const MAX_WRITE_PREVIEW_LINES = 20;
+function WritePreview({ path, content }) {
+    const lines = content.split("\n");
+    const shown = lines.slice(0, MAX_WRITE_PREVIEW_LINES);
+    const overflow = lines.length - shown.length;
+    const totalBytes = Buffer.byteLength(content, "utf-8");
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: compressHome(path) }), _jsxs(Text, { color: theme.muted, children: [" \u00B7 ", lines.length, " line", lines.length === 1 ? "" : "s", " \u00B7 ", formatBytes(totalBytes)] })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [shown.map((line, i) => (_jsxs(Text, { color: "green", children: ["+ ", line || " "] }, i))), overflow > 0 && (_jsxs(Text, { color: theme.muted, children: ["\u2026 ", overflow, " more line", overflow === 1 ? "" : "s"] }))] })] }));
+}
+function formatBytes(n) {
+    if (n < 1024)
+        return `${n}B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)}KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)}MB`;
+}
+function compressHome(p) {
+    const home = process.env.HOME || "";
+    if (home && p.startsWith(home))
+        return `~${p.slice(home.length)}`;
+    return p;
+}

package/dist/tui-ink/approval/diff-view.d.ts

@@ -0,0 +1,7 @@
+interface DiffViewProps {
+    diff: string;
+    /** Hard cap on total rendered lines across all hunks. Excess is truncated. */
+    maxLines?: number;
+}
+export declare function DiffView({ diff, maxLines }: DiffViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/tui-ink/approval/diff-view.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { theme } from "../theme.js";
+import { parseDiffHunks } from "../../approval/diff-hunks.js";
+const DEFAULT_MAX_LINES = 40;
+export function DiffView({ diff, maxLines = DEFAULT_MAX_LINES }) {
+    const hunks = parseDiffHunks(diff);
+    if (hunks.length === 0) {
+        return (_jsx(Text, { color: theme.muted, children: "(no diff body to display)" }));
+    }
+    // Distribute the line budget across hunks. Simple approach: render hunks in
+    // order until the budget is exhausted; if a hunk overflows, keep its header,
+    // show as many body lines as fit, then emit a "… N more" marker.
+    let remaining = maxLines;
+    const rendered = [];
+    let trailingSkipped = 0;
+    for (let i = 0; i < hunks.length; i++) {
+        const hunk = hunks[i];
+        if (remaining <= 1) {
+            trailingSkipped += hunk.lines.length + 1;
+            continue;
+        }
+        remaining -= 1; // header line
+        const available = Math.max(0, remaining);
+        if (hunk.lines.length <= available) {
+            rendered.push({ hunk, shown: hunk.lines, truncatedBy: 0 });
+            remaining -= hunk.lines.length;
+        }
+        else {
+            const shown = hunk.lines.slice(0, available);
+            rendered.push({ hunk, shown, truncatedBy: hunk.lines.length - available });
+            remaining = 0;
+        }
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [rendered.map(({ hunk, shown, truncatedBy }, i) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: theme.accent, children: hunk.header }), shown.map((line, j) => (_jsx(Text, { color: colorForDiffLine(line), children: line || " " }, j))), truncatedBy > 0 && (_jsxs(Text, { color: theme.muted, children: ["\u2026 ", truncatedBy, " more line", truncatedBy === 1 ? "" : "s", " in this hunk"] }))] }, i))), trailingSkipped > 0 && (_jsxs(Text, { color: theme.muted, children: ["\u2026 ", trailingSkipped, " more line", trailingSkipped === 1 ? "" : "s", " across later hunks"] }))] }));
+}
+function colorForDiffLine(line) {
+    if (line.startsWith("+"))
+        return "green";
+    if (line.startsWith("-"))
+        return "red";
+    return undefined;
+}

package/dist/tui-ink/approval/select.d.ts

@@ -0,0 +1,35 @@
+export interface ApprovalOption {
+    /** Stable identifier returned to the parent. */
+    id: string;
+    /** Primary label shown in the menu. */
+    label: string;
+    /** Dim description appended after the label. */
+    description?: string;
+    /** If true, Tab on this option turns it into a feedback input. */
+    allowAmend?: boolean;
+    /** Placeholder shown in the amend input. */
+    amendPlaceholder?: string;
+    /**
+     * If set, this option has an inline-editable data value (rendered right
+     * after `label`). When the option is focused, typing modifies the value;
+     * backspace removes the last character. Use-case: "Yes, and don't ask
+     * again for `<prefix>`" — the prefix is editable before submit.
+     */
+    editableValue?: {
+        initial: string;
+        placeholder?: string;
+    };
+}
+export type ApprovalSubmit = (optionId: string, extras: {
+    feedback?: string;
+    editedValue?: string;
+}) => void;
+interface ApprovalSelectProps {
+    options: ApprovalOption[];
+    onSubmit: ApprovalSubmit;
+    onCancel: () => void;
+    hint?: string;
+    initialIndex?: number;
+}
+export declare function ApprovalSelect({ options, onSubmit, onCancel, hint, initialIndex, }: ApprovalSelectProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/tui-ink/approval/select.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { theme } from "../theme.js";
+export function ApprovalSelect({ options, onSubmit, onCancel, hint, initialIndex = 0, }) {
+    const [focusIndex, setFocusIndex] = useState(Math.max(0, Math.min(initialIndex, options.length - 1)));
+    const [amending, setAmending] = useState(false);
+    const [amendText, setAmendText] = useState("");
+    // Map of option.id → current edited value. Populated lazily so navigating
+    // away and back preserves edits.
+    const [editedValues, setEditedValues] = useState(() => {
+        const seed = {};
+        for (const opt of options) {
+            if (opt.editableValue)
+                seed[opt.id] = opt.editableValue.initial;
+        }
+        return seed;
+    });
+    const focused = options[focusIndex];
+    const canAmend = !!focused?.allowAmend;
+    const hasEditableValue = !!focused?.editableValue;
+    const currentValue = focused?.editableValue ? editedValues[focused.id] ?? "" : "";
+    useInput((input, key) => {
+        if (amending) {
+            if (key.escape) {
+                setAmending(false);
+                setAmendText("");
+                return;
+            }
+            if (key.return) {
+                const editedValue = focused.editableValue ? currentValue : undefined;
+                onSubmit(focused.id, { feedback: amendText.trim() || undefined, editedValue });
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setAmendText((prev) => prev.slice(0, -1));
+                return;
+            }
+            if (input) {
+                setAmendText((prev) => prev + input);
+            }
+            return;
+        }
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        // Vertical nav always works regardless of editable value, so the user can
+        // still move off an option they don't want.
+        if (key.upArrow) {
+            setFocusIndex((i) => (i - 1 + options.length) % options.length);
+            return;
+        }
+        if (key.downArrow) {
+            setFocusIndex((i) => (i + 1) % options.length);
+            return;
+        }
+        if (key.return) {
+            const editedValue = focused.editableValue ? currentValue : undefined;
+            onSubmit(focused.id, { editedValue });
+            return;
+        }
+        if (key.tab && canAmend) {
+            setAmending(true);
+            setAmendText("");
+            return;
+        }
+        // When the focused option has an editable value, plain keypresses mutate it.
+        if (hasEditableValue) {
+            if (key.backspace || key.delete) {
+                setEditedValues((prev) => ({ ...prev, [focused.id]: (prev[focused.id] ?? "").slice(0, -1) }));
+                return;
+            }
+            if (input && !key.ctrl && !key.meta) {
+                setEditedValues((prev) => ({ ...prev, [focused.id]: (prev[focused.id] ?? "") + input }));
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [options.map((option, idx) => {
+                const isFocused = idx === focusIndex;
+                const value = option.editableValue ? editedValues[option.id] ?? "" : undefined;
+                if (isFocused && amending) {
+                    return (_jsxs(Box, { children: [_jsx(Text, { color: theme.accent, children: "› " }), _jsxs(Text, { bold: true, children: [option.label, ":"] }), _jsx(Text, { children: " " }), _jsx(Text, { color: amendText ? undefined : theme.muted, children: amendText || option.amendPlaceholder || "type feedback…" }), _jsx(Text, { backgroundColor: "white", color: "black", children: " " })] }, option.id));
+                }
+                return (_jsxs(Box, { children: [_jsx(Text, { color: isFocused ? theme.accent : theme.muted, children: isFocused ? "› " : "  " }), _jsx(Text, { bold: isFocused, color: isFocused ? undefined : theme.muted, children: option.label }), option.editableValue && (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: " " }), _jsx(Text, { color: isFocused ? theme.accent : theme.muted, children: "[" }), _jsx(Text, { color: isFocused ? undefined : theme.muted, children: value || option.editableValue.placeholder || "" }), isFocused && (_jsx(Text, { backgroundColor: "white", color: "black", children: " " })), _jsx(Text, { color: isFocused ? theme.accent : theme.muted, children: "]" })] })), option.description && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: theme.muted, children: option.description })] }))] }, option.id));
+            }), hint && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: hint }) }))] }));
+}

package/dist/tui-ink/code-highlight.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Lightweight code highlighting for TUI using Shiki.
+ * Converts token colors to ANSI escape codes for Ink rendering.
+ */
+export declare function highlightCode(code: string, lang: string): Promise<string>;
+export declare function inferLang(path?: string): string;

package/dist/tui-ink/code-highlight.js

@@ -0,0 +1,94 @@
+/**
+ * Lightweight code highlighting for TUI using Shiki.
+ * Converts token colors to ANSI escape codes for Ink rendering.
+ */
+import { createHighlighter } from "shiki";
+let highlighterPromise = null;
+function getHighlighter() {
+    if (!highlighterPromise) {
+        highlighterPromise = createHighlighter({
+            themes: ["github-dark"],
+            langs: [
+                "bash",
+                "css",
+                "diff",
+                "dockerfile",
+                "go",
+                "html",
+                "ini",
+                "javascript",
+                "json",
+                "jsx",
+                "markdown",
+                "python",
+                "rust",
+                "shell",
+                "sql",
+                "typescript",
+                "tsx",
+                "yaml",
+            ],
+        });
+    }
+    return highlighterPromise;
+}
+function hexToAnsiFg(hex) {
+    if (!hex)
+        return "";
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+function tokensToAnsi(tokens) {
+    const lines = [];
+    for (const line of tokens) {
+        let lineStr = "";
+        for (const token of line) {
+            lineStr += hexToAnsiFg(token.color) + token.content;
+        }
+        lineStr += "\x1b[0m";
+        lines.push(lineStr);
+    }
+    return lines.join("\n");
+}
+export async function highlightCode(code, lang) {
+    const h = await getHighlighter();
+    const loaded = h.getLoadedLanguages();
+    const safeLang = loaded.includes(lang) ? lang : "text";
+    const { tokens } = h.codeToTokens(code, { lang: safeLang, theme: "github-dark" });
+    return tokensToAnsi(tokens);
+}
+const LANG_MAP = {
+    bash: "bash",
+    css: "css",
+    diff: "diff",
+    dockerfile: "dockerfile",
+    go: "go",
+    html: "html",
+    htm: "html",
+    ini: "ini",
+    cfg: "ini",
+    toml: "ini",
+    js: "javascript",
+    json: "json",
+    jsx: "jsx",
+    md: "markdown",
+    mdx: "markdown",
+    py: "python",
+    rs: "rust",
+    sh: "bash",
+    shell: "shell",
+    sql: "sql",
+    ts: "typescript",
+    tsx: "tsx",
+    yaml: "yaml",
+    yml: "yaml",
+    zsh: "bash",
+};
+export function inferLang(path) {
+    if (!path)
+        return "text";
+    const ext = path.split(".").pop()?.toLowerCase();
+    return (ext && LANG_MAP[ext]) || "text";
+}

package/dist/tui-ink/display-history.d.ts

@@ -0,0 +1,38 @@
+import type { ToolResultMetadata } from "../types.js";
+export interface DisplayMessage {
+    /** Stable identity, used as Static/list key. Generated by the UI layer. */
+    key?: string;
+    role: "user" | "assistant" | "error";
+    content: string;
+    reasoning?: string;
+    toolCalls?: DisplayToolCall[];
+    parts?: DisplayMessagePart[];
+    syntheticKind?: "ui_summary";
+    hiddenCount?: number;
+}
+export type DisplayMessagePart = DisplayTextPart | DisplayToolsPart;
+export interface DisplayTextPart {
+    type: "text";
+    content: string;
+}
+export interface DisplayToolsPart {
+    type: "tools";
+    toolCalls: DisplayToolCall[];
+}
+export interface DisplayToolCall {
+    id: string;
+    name: string;
+    args: Record<string, any>;
+    result?: string;
+    isError?: boolean;
+    metadata?: ToolResultMetadata;
+    /** Set when the tool_start event was received. Used to render elapsed time. */
+    startedAt?: number;
+}
+export declare function nextDisplayMessageKey(prefix?: string): string;
+export declare function appendTextPart(parts: DisplayMessagePart[], content: string): void;
+export declare function appendToolPart(parts: DisplayMessagePart[], toolCall: DisplayToolCall): void;
+export declare function snapshotDisplayParts(parts: DisplayMessagePart[]): DisplayMessagePart[];
+export declare function contentFromParts(parts: DisplayMessagePart[]): string;
+export declare function toolCallsFromParts(parts: DisplayMessagePart[]): DisplayToolCall[];
+export declare function compactDisplayMessages(messages: DisplayMessage[]): DisplayMessage[];

package/dist/tui-ink/display-history.js

@@ -0,0 +1,130 @@
+let __displayMessageCounter = 0;
+export function nextDisplayMessageKey(prefix = "msg") {
+    __displayMessageCounter += 1;
+    return `${prefix}-${__displayMessageCounter}`;
+}
+export function appendTextPart(parts, content) {
+    if (!content)
+        return;
+    const last = parts[parts.length - 1];
+    if (last?.type === "text") {
+        last.content += content;
+    }
+    else {
+        parts.push({ type: "text", content });
+    }
+}
+export function appendToolPart(parts, toolCall) {
+    const last = parts[parts.length - 1];
+    if (last?.type === "tools") {
+        last.toolCalls.push(toolCall);
+    }
+    else {
+        parts.push({ type: "tools", toolCalls: [toolCall] });
+    }
+}
+export function snapshotDisplayParts(parts) {
+    return parts.map((part) => {
+        if (part.type === "text") {
+            return { ...part };
+        }
+        return {
+            type: "tools",
+            toolCalls: part.toolCalls.map(cloneToolCall),
+        };
+    });
+}
+export function contentFromParts(parts) {
+    return parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.content)
+        .join("");
+}
+export function toolCallsFromParts(parts) {
+    return parts.flatMap((part) => part.type === "tools" ? part.toolCalls : []);
+}
+const MAX_VISIBLE_MESSAGES = 80;
+const FULL_DETAIL_WINDOW = 24;
+const MAX_OLD_CONTENT_CHARS = 1200;
+const MAX_OLD_REASONING_CHARS = 600;
+const MAX_OLD_TOOL_RESULT_CHARS = 800;
+export function compactDisplayMessages(messages) {
+    if (messages.length === 0) {
+        return messages;
+    }
+    let hiddenCount = 0;
+    const withoutSynthetic = messages.filter((message) => {
+        if (message.syntheticKind !== "ui_summary") {
+            return true;
+        }
+        hiddenCount += message.hiddenCount ?? 0;
+        return false;
+    });
+    const overflow = Math.max(0, withoutSynthetic.length - MAX_VISIBLE_MESSAGES);
+    hiddenCount += overflow;
+    const visible = overflow > 0 ? withoutSynthetic.slice(overflow) : withoutSynthetic;
+    const detailStart = Math.max(0, visible.length - FULL_DETAIL_WINDOW);
+    const compacted = visible.map((message, index) => (index < detailStart ? compactDisplayMessage(message) : message));
+    if (hiddenCount === 0) {
+        return compacted;
+    }
+    return [buildUiSummary(hiddenCount), ...compacted];
+}
+function compactDisplayMessage(message) {
+    if (message.syntheticKind === "ui_summary") {
+        return message;
+    }
+    return {
+        ...message,
+        content: truncateText(message.content, MAX_OLD_CONTENT_CHARS),
+        reasoning: message.reasoning
+            ? truncateText(message.reasoning, MAX_OLD_REASONING_CHARS)
+            : message.reasoning,
+        toolCalls: message.toolCalls?.map(compactToolCall),
+        parts: message.parts?.map(compactDisplayPart),
+    };
+}
+function buildUiSummary(hiddenCount) {
+    return {
+        key: "synthetic-ui-summary",
+        role: "assistant",
+        content: `[Earlier UI history compacted to control memory: ${hiddenCount} message${hiddenCount === 1 ? "" : "s"} hidden]`,
+        syntheticKind: "ui_summary",
+        hiddenCount,
+    };
+}
+function truncateText(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    const head = Math.max(1, Math.floor(maxChars * 0.7));
+    const tail = Math.max(1, maxChars - head - 32);
+    const omitted = value.length - head - tail;
+    return `${value.slice(0, head)}\n...[${omitted} chars omitted for UI]...\n${value.slice(-tail)}`;
+}
+function cloneToolCall(toolCall) {
+    return {
+        ...toolCall,
+        args: { ...toolCall.args },
+    };
+}
+function compactDisplayPart(part) {
+    if (part.type === "text") {
+        return {
+            ...part,
+            content: truncateText(part.content, MAX_OLD_CONTENT_CHARS),
+        };
+    }
+    return {
+        type: "tools",
+        toolCalls: part.toolCalls.map(compactToolCall),
+    };
+}
+function compactToolCall(toolCall) {
+    return {
+        ...toolCall,
+        result: toolCall.result
+            ? truncateText(toolCall.result, MAX_OLD_TOOL_RESULT_CHARS)
+            : toolCall.result,
+    };
+}

package/dist/tui-ink/edit-diff.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayToolCall } from "./display-history.js";
+export declare const EDIT_COLLAPSED_DIFF_LINES = 20;
+export interface EditDiffDetails {
+    diff: string;
+    added: number;
+    removed: number;
+    path?: string;
+}
+export declare function getEditDiffDetails(tool: DisplayToolCall): EditDiffDetails | null;
+export declare function formatEditSuccessSummary(details: EditDiffDetails | null): string;
+export declare function formatEditStats(added: number, removed: number): string;

package/dist/tui-ink/edit-diff.js

@@ -0,0 +1,52 @@
+import { countUnifiedDiffChanges } from "../diff-stats.js";
+export const EDIT_COLLAPSED_DIFF_LINES = 20;
+export function getEditDiffDetails(tool) {
+    if (tool.name !== "edit" || tool.isError)
+        return null;
+    const metadata = tool.metadata;
+    const metadataDiff = readMetadataString(metadata, "diff");
+    const diff = metadataDiff ?? extractDiffFromResult(tool.result);
+    if (!diff)
+        return null;
+    const counted = countUnifiedDiffChanges(diff);
+    const added = readMetadataNumber(metadata, "addedLines") ?? counted.added;
+    const removed = readMetadataNumber(metadata, "removedLines") ?? counted.removed;
+    const path = readMetadataString(metadata, "path")
+        ?? (typeof tool.args.path === "string" ? tool.args.path : undefined);
+    return { diff, added, removed, path };
+}
+export function formatEditSuccessSummary(details) {
+    const stats = details ? formatEditStats(details.added, details.removed) : "";
+    return `Succeeded. File edited.${stats ? ` ${stats}` : ""}`;
+}
+export function formatEditStats(added, removed) {
+    const parts = [];
+    if (added > 0)
+        parts.push(`+${added} added`);
+    if (removed > 0)
+        parts.push(`-${removed} removed`);
+    if (parts.length === 0)
+        return "";
+    return `(${parts.join(", ")})`;
+}
+function extractDiffFromResult(result) {
+    if (!result)
+        return null;
+    const normalized = result.replace(/\r\n/g, "\n");
+    const marker = "\nDiff:\n";
+    const index = normalized.indexOf(marker);
+    if (index === -1)
+        return null;
+    const rawDiff = normalized.slice(index + marker.length);
+    const diagnosticsIndex = rawDiff.search(/\n\nLSP diagnostics in /);
+    const diff = diagnosticsIndex === -1 ? rawDiff : rawDiff.slice(0, diagnosticsIndex);
+    return diff.trim().length > 0 ? diff : null;
+}
+function readMetadataString(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function readMetadataNumber(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}