codebase-cli 2.0.0-pre.3 → 2.0.0-pre.30

package/dist/ui/Message.js

@@ -1,12 +1,37 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { isAbsolute, sep as pathSep, relative as relativePath, resolve as resolveAbsolute } from "node:path";
+import { diffLines, diffWordsWithSpace } from "diff";
 import { Box, Text } from "ink";
+import { useEffect, useState } from "react";
+import { Markdown } from "./Markdown.js";
 import { wrapText } from "./wrap.js";
+const SPINNER_FRAMES = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"];
+function useSpinner(active, intervalMs = 90) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        if (!active)
+            return;
+        const id = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), intervalMs);
+        return () => clearInterval(id);
+    }, [active, intervalMs]);
+    return SPINNER_FRAMES[frame];
+}
 const ROLE_STYLE = {
     user: { accent: "yellow", label: "you" },
     assistant: { accent: "cyan", label: "codebase" },
     toolResult: { accent: "magenta", label: "tool" },
 };
-export function Message({ message, streaming, width = 80 }) {
+/**
+ * Per-tool name overrides for the toolResult header label. Default falls
+ * back to the raw tool name (read_file, grep, shell, …) which is more
+ * useful than a generic "tool". A few tools get friendlier presentation
+ * labels because their raw name reads oddly in the gutter.
+ */
+const TOOL_RESULT_LABEL = {
+    shell: "bash",
+    dispatch_agent: "subagent",
+};
+export function Message({ message, streaming, width = 80, tools }) {
     const role = message.role;
     const style = ROLE_STYLE[role];
     if (!style)
@@ -15,36 +40,376 @@ export function Message({ message, streaming, width = 80 }) {
     // gap, plus the parent App's paddingX of 1 each side. Reserve 4 cols so
     // the wrapped text never tries to occupy the accent gutter.
     const bodyWidth = Math.max(20, width - 4);
-    return (_jsxs(Box, { flexDirection: "row", marginY: 0, children: [_jsx(Box, { marginRight: 1, children: _jsx(Text, { color: style.accent, children: "\u2502" }) }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsxs(Text, { color: style.accent, bold: true, children: [style.label, streaming ? " …" : ""] }), _jsx(MessageBody, { message: message, width: bodyWidth })] })] }));
+    // Tool results carry the originating tool name on the message itself
+    // (set by pi-agent-core). Surface that instead of the generic "tool"
+    // label so users can see at a glance which tool produced this output.
+    const headerLabel = role === "toolResult" && "toolName" in message && typeof message.toolName === "string"
+        ? (TOOL_RESULT_LABEL[message.toolName] ?? message.toolName)
+        : style.label;
+    return (_jsxs(Box, { flexDirection: "row", marginY: 0, children: [_jsx(Box, { marginRight: 1, children: _jsx(Text, { color: style.accent, children: "\u2502" }) }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsxs(Text, { color: style.accent, bold: true, children: [headerLabel, streaming ? " …" : ""] }), _jsx(MessageBody, { message: message, width: bodyWidth, tools: tools })] })] }));
 }
-function MessageBody({ message, width }) {
+function MessageBody({ message, width, tools, }) {
     if (message.role === "user") {
-        const text = typeof message.content === "string" ? message.content : renderUserContent(message.content);
-        return _jsx(WrappedLines, { text: text, width: width, keyPrefix: "user" });
+        if (typeof message.content === "string") {
+            return _jsx(WrappedLines, { text: message.content, width: width, keyPrefix: "user" });
+        }
+        return _jsx(UserBlocks, { blocks: message.content, width: width });
     }
     if (message.role === "assistant") {
-        return (_jsxs(_Fragment, { children: [message.content.map((block, idx) => {
-                    const key = blockKey(block, idx);
-                    if (block.type === "text") {
-                        return _jsx(WrappedLines, { text: block.text, width: width, keyPrefix: key }, key);
-                    }
-                    if (block.type === "thinking") {
-                        return (_jsx(WrappedLines, { text: `(thinking) ${block.thinking}`, width: width, keyPrefix: key, dimColor: true, italic: true }, key));
-                    }
-                    if (block.type === "toolCall") {
-                        return (_jsx(WrappedLines, { text: `→ ${block.name}(${summarizeArgs(block.arguments)})`, width: width, keyPrefix: key, color: "magenta" }, key));
-                    }
-                    return null;
-                }), message.errorMessage ? (_jsx(WrappedLines, { text: `! ${message.errorMessage}`, width: width, keyPrefix: "err", color: "red" })) : null] }));
+        const rendered = renderAssistantBlocks(message.content, width, tools);
+        return (_jsxs(_Fragment, { children: [rendered, message.errorMessage ? (_jsx(WrappedLines, { text: `! ${message.errorMessage}`, width: width, keyPrefix: "err", color: "red" })) : null] }));
     }
     if (message.role === "toolResult") {
         const text = message.content
             .map((block) => (block.type === "text" ? block.text : `[image:${block.mimeType}]`))
             .join("");
-        return _jsx(WrappedLines, { text: text, width: width, keyPrefix: "tool", color: message.isError ? "red" : undefined });
+        const toolName = "toolName" in message && typeof message.toolName === "string" ? message.toolName : undefined;
+        return (_jsx(TruncatedOutput, { text: text, width: width, keyPrefix: "tool", color: message.isError ? "red" : undefined, toolName: toolName }));
     }
     return null;
 }
+/**
+ * One tool-call row that morphs through three states:
+ *   running  → spinner + present tense  ("⣾ Reading src/index.ts")
+ *   done     → ✓ + past tense           ("✓ Read src/index.ts")
+ *   error    → ✗ + past tense + red     ("✗ Read src/index.ts")
+ *
+ * State source: the per-session `tools` Map on ChatState. If no entry
+ * exists for this id (e.g. an old session being replayed without
+ * inflight tracking), we render the past-tense "done" form — safe
+ * fallback that never strands the UI on a fake spinner.
+ */
+function ToolCallLine({ id, name, args, width, keyPrefix, tools, }) {
+    const exec = tools?.get(id);
+    const status = exec?.status ?? "done";
+    const isRunning = status === "running";
+    const spinner = useSpinner(isRunning);
+    if (isRunning) {
+        return (_jsx(WrappedLines, { text: `${spinner} ${toolActionLabel(name, args)}…`, width: width, keyPrefix: keyPrefix, color: "magenta" }));
+    }
+    const isError = status === "error";
+    const glyph = isError ? "✗" : "✓";
+    const past = toolActionPast(name, args);
+    const diff = !isError ? diffSummary(name, args) : null;
+    return (_jsxs(_Fragment, { children: [_jsx(WrappedLines, { text: `${glyph} ${past}`, width: width, keyPrefix: keyPrefix, color: isError ? "red" : "magenta" }), diff ? _jsx(DiffSummary, { diff: diff, width: width, keyPrefix: `${keyPrefix}-diff` }) : null] }));
+}
+/**
+ * Tool calls that are pure reads — runs of these collapse into a single
+ * "Read N files" / "Searched 3 patterns" line, the Claude Code pattern.
+ * Keep the set tight: anything that mutates state, runs shell, or has a
+ * meaningful argument shape (grep query, fetch URL) reads weird when
+ * collapsed and stays per-row.
+ */
+const COLLAPSIBLE_READ_TOOLS = new Set(["read_file"]);
+/**
+ * Walk an assistant message's content blocks, collapsing runs of
+ * consecutive `read_file` (and other safe read-only) tool calls into a
+ * single summary row. A run only collapses when every call in it is
+ * completed (done or errored) — if any is still running we render the
+ * group expanded so the spinner stays visible on the active row.
+ */
+function renderAssistantBlocks(content, width, tools) {
+    const out = [];
+    let i = 0;
+    while (i < content.length) {
+        const block = content[i];
+        const key = blockKey(block, i);
+        if (block.type === "text") {
+            out.push(_jsx(Markdown, { text: block.text, width: width, keyPrefix: key }, key));
+            i++;
+            continue;
+        }
+        if (block.type === "thinking") {
+            out.push(_jsx(WrappedLines, { text: `(thinking) ${block.thinking}`, width: width, keyPrefix: key, dimColor: true, italic: true }, key));
+            i++;
+            continue;
+        }
+        if (block.type === "toolCall") {
+            if (COLLAPSIBLE_READ_TOOLS.has(block.name)) {
+                let runEnd = i + 1;
+                while (runEnd < content.length) {
+                    const next = content[runEnd];
+                    if (next.type !== "toolCall" || next.name !== block.name)
+                        break;
+                    runEnd++;
+                }
+                const run = [];
+                for (let j = i; j < runEnd; j++) {
+                    const b = content[j];
+                    if (b.type === "toolCall")
+                        run.push(b);
+                }
+                if (run.length >= 2) {
+                    out.push(_jsx(CollapsedReadGroup, { calls: run, width: width, keyPrefix: `run-${run[0].id}`, tools: tools }, `run-${run[0].id}`));
+                    i = runEnd;
+                    continue;
+                }
+            }
+            out.push(_jsx(ToolCallLine, { id: block.id, name: block.name, args: block.arguments, width: width, keyPrefix: key, tools: tools }, key));
+            i++;
+            continue;
+        }
+        i++;
+    }
+    return out;
+}
+function CollapsedReadGroup({ calls, width, keyPrefix, tools, }) {
+    const statuses = calls.map((c) => tools?.get(c.id)?.status);
+    const anyRunning = statuses.some((s) => s === "running");
+    const anyError = statuses.some((s) => s === "error");
+    const doneCount = statuses.filter((s) => s !== "running").length;
+    const spinner = useSpinner(anyRunning);
+    const glyph = anyRunning ? spinner : anyError ? "✗" : "✓";
+    const color = anyError ? "red" : "magenta";
+    const verb = anyRunning ? presentVerbForReadTool(calls[0].name) : pastVerbForReadTool(calls[0].name);
+    const noun = nounForReadTool(calls[0].name, calls.length);
+    const header = anyRunning
+        ? `${glyph} ${verb} ${doneCount} of ${calls.length} ${noun}…`
+        : `${glyph} ${verb} ${calls.length} ${noun}`;
+    return (_jsxs(_Fragment, { children: [_jsx(WrappedLines, { text: header, width: width, keyPrefix: keyPrefix, color: color }), _jsx(Box, { flexDirection: "column", marginLeft: 2, children: calls.map((c) => {
+                    const a = (c.arguments ?? {});
+                    const rawPath = typeof a.path === "string" ? a.path : typeof a.file_path === "string" ? a.file_path : "";
+                    const path = displayPath(rawPath);
+                    const status = tools?.get(c.id)?.status;
+                    const failed = status === "error";
+                    const running = status === "running";
+                    const marker = failed ? "  ✗ " : running ? "  → " : "  · ";
+                    return (_jsxs(Text, { color: failed ? "red" : running ? "magenta" : undefined, dimColor: !failed && !running, children: [marker, truncate(path, Math.max(20, width - 6))] }, `${keyPrefix}-f-${c.id}`));
+                }) })] }));
+}
+function presentVerbForReadTool(name) {
+    if (name === "read_file")
+        return "Reading";
+    if (name === "list_files")
+        return "Listing";
+    if (name === "glob")
+        return "Searching";
+    if (name === "grep")
+        return "Grepping";
+    return "Running";
+}
+function pastVerbForReadTool(name) {
+    if (name === "read_file")
+        return "Read";
+    if (name === "list_files")
+        return "Listed";
+    if (name === "glob")
+        return "Searched";
+    if (name === "grep")
+        return "Grepped";
+    return "Ran";
+}
+function nounForReadTool(name, count) {
+    if (name === "read_file")
+        return count === 1 ? "file" : "files";
+    if (name === "list_files")
+        return count === 1 ? "directory" : "directories";
+    return count === 1 ? "call" : "calls";
+}
+/** How many change lines we'll render before collapsing to just the +/- counts. */
+const MAX_HUNK_LINES = 12;
+/**
+ * Build a diff summary for a completed file-edit tool call from the
+ * tool's args. We have old_string + new_string right there, so no
+ * filesystem round-trip needed. Uses the `diff` library's LCS-based
+ * line pairing — adding a single line at the top no longer marks the
+ * whole rest of the file as "changed."
+ */
+function diffSummary(name, args) {
+    const a = (args ?? {});
+    if (name === "edit_file") {
+        const oldStr = typeof a.old_string === "string" ? a.old_string : "";
+        const newStr = typeof a.new_string === "string" ? a.new_string : "";
+        if (!oldStr && !newStr)
+            return null;
+        return buildDiff(oldStr, newStr);
+    }
+    if (name === "multi_edit") {
+        const edits = Array.isArray(a.edits) ? a.edits : [];
+        let added = 0;
+        let removed = 0;
+        const hunks = [];
+        let truncated = false;
+        for (const e of edits) {
+            if (!e || typeof e !== "object")
+                continue;
+            const ed = e;
+            const oldStr = typeof ed.old_string === "string" ? ed.old_string : "";
+            const newStr = typeof ed.new_string === "string" ? ed.new_string : "";
+            const sub = buildDiff(oldStr, newStr);
+            added += sub.added;
+            removed += sub.removed;
+            truncated = truncated || sub.truncated;
+            hunks.push(...sub.hunks);
+        }
+        if (added === 0 && removed === 0)
+            return null;
+        return {
+            added,
+            removed,
+            hunks: hunks.slice(0, MAX_HUNK_LINES),
+            truncated: truncated || hunks.length > MAX_HUNK_LINES,
+        };
+    }
+    if (name === "write_file") {
+        const content = typeof a.content === "string" ? a.content : "";
+        if (!content)
+            return null;
+        const lines = content.split("\n").length;
+        return { added: lines, removed: 0, hunks: [], truncated: false };
+    }
+    return null;
+}
+/**
+ * LCS-based line diff, then pair adjacent remove+add changes so we can
+ * surface a word-level highlight on each paired line. When a pair has
+ * the same number of lines on each side, we line-align them and run
+ * diffWordsWithSpace per row — that's the cleanest case and matches
+ * the user expectation of "show me what actually changed in this row."
+ */
+function buildDiff(oldStr, newStr) {
+    const changes = diffLines(oldStr, newStr);
+    const hunks = [];
+    let added = 0;
+    let removed = 0;
+    const lineCount = (s) => (s ? s.replace(/\n$/, "").split("\n").length : 0);
+    for (let i = 0; i < changes.length; i++) {
+        const c = changes[i];
+        if (c.added)
+            added += lineCount(c.value);
+        if (c.removed)
+            removed += lineCount(c.value);
+        const next = changes[i + 1];
+        const isPair = c.removed && next?.added;
+        if (isPair) {
+            const removeLines = c.value.replace(/\n$/, "").split("\n");
+            const addLines = next.value.replace(/\n$/, "").split("\n");
+            if (removeLines.length === addLines.length) {
+                // Paired row-by-row → word-level diff per row.
+                for (let j = 0; j < removeLines.length; j++) {
+                    const parts = diffWordsWithSpace(removeLines[j], addLines[j]);
+                    hunks.push({
+                        type: "remove",
+                        text: removeLines[j],
+                        wordParts: parts.filter((p) => !p.added).map((p) => ({ text: p.value, highlight: !!p.removed })),
+                    });
+                    hunks.push({
+                        type: "add",
+                        text: addLines[j],
+                        wordParts: parts.filter((p) => !p.removed).map((p) => ({ text: p.value, highlight: !!p.added })),
+                    });
+                }
+            }
+            else {
+                // Asymmetric pair — show all removes then all adds without word diff.
+                for (const line of removeLines)
+                    hunks.push({ type: "remove", text: line });
+                for (const line of addLines)
+                    hunks.push({ type: "add", text: line });
+            }
+            i++; // Consume the paired add change.
+            continue;
+        }
+        if (c.removed || c.added) {
+            const type = c.added ? "add" : "remove";
+            for (const line of c.value.replace(/\n$/, "").split("\n")) {
+                hunks.push({ type, text: line });
+            }
+        }
+        // Context (neither added nor removed) is dropped — the +N/-M
+        // counts plus the change lines themselves give enough orientation
+        // for the small previews we render.
+    }
+    const truncated = hunks.length > MAX_HUNK_LINES;
+    return { added, removed, hunks: hunks.slice(0, MAX_HUNK_LINES), truncated };
+}
+/**
+ * Render the +N -M summary line, then up to MAX_HUNK_LINES change lines.
+ * Removed lines render in red, added lines in green. Within a paired
+ * remove/add row, the actually-changed words get a brighter background
+ * so the eye lands on the substantive change immediately.
+ */
+function DiffSummary({ diff, width, keyPrefix }) {
+    const counts = diff.truncated
+        ? `    +${diff.added} -${diff.removed} (preview truncated)`
+        : `    +${diff.added} -${diff.removed}`;
+    const lineWidth = Math.max(20, width - 8);
+    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsx(Text, { dimColor: true, children: counts }), diff.hunks.map((h, i) => {
+                const isRemove = h.type === "remove";
+                const sign = isRemove ? "    - " : "    + ";
+                const lineColor = isRemove ? "red" : "green";
+                const hlBg = isRemove ? "redBright" : "greenBright";
+                const key = `${keyPrefix}-h-${i}-${h.type}-${h.text.slice(0, 24)}`;
+                if (h.wordParts && h.wordParts.length > 0) {
+                    // Truncate at the part boundary that crosses the width budget.
+                    let used = 0;
+                    const visibleParts = [];
+                    for (const p of h.wordParts) {
+                        const remaining = lineWidth - used;
+                        if (remaining <= 0)
+                            break;
+                        if (p.text.length <= remaining) {
+                            visibleParts.push(p);
+                            used += p.text.length;
+                        }
+                        else {
+                            visibleParts.push({ ...p, text: `${p.text.slice(0, Math.max(0, remaining - 1))}…` });
+                            break;
+                        }
+                    }
+                    // Stable keys per-word: counter-suffix is only for collision when
+                    // the same word appears multiple times in a line. Avoids the
+                    // array-index-as-key smell while keeping React's reconciler happy.
+                    const seenCounts = new Map();
+                    const keyedParts = visibleParts.map((p) => {
+                        const baseKey = `${p.highlight ? "h" : "n"}:${p.text}`;
+                        const count = seenCounts.get(baseKey) ?? 0;
+                        seenCounts.set(baseKey, count + 1);
+                        return { part: p, k: `${key}-w-${baseKey}-${count}` };
+                    });
+                    return (_jsxs(Box, { children: [_jsx(Text, { color: lineColor, children: sign }), _jsx(Text, { children: keyedParts.map(({ part, k }) => (_jsx(Text, { color: lineColor, backgroundColor: part.highlight ? hlBg : undefined, children: part.text }, k))) })] }, key));
+                }
+                return (_jsxs(Text, { color: lineColor, children: [sign, truncate(h.text, lineWidth)] }, key));
+            })] }));
+}
+const DEFAULT_MAX_TOOL_OUTPUT_LINES = 12;
+/**
+ * Per-tool display caps. Search-style tools (grep, find, glob) produce
+ * many matches, most of which the user doesn't need to read inline —
+ * the model still sees the full result. Default is 12 lines.
+ */
+const TOOL_OUTPUT_LIMITS = {
+    grep: 6,
+    search_files: 6,
+    glob: 8,
+    find: 8,
+    list_files: 10,
+};
+/**
+ * Truncate tool output past the per-tool limit into "head + (N hidden)
+ * + tail" — long shell or grep output otherwise dominates the
+ * transcript and pushes context off-screen. The agent still gets the
+ * full output; this is purely a display trim. Errors are NEVER
+ * truncated since the user needs to see exactly what blew up.
+ */
+function TruncatedOutput({ text, width, keyPrefix, color, toolName, }) {
+    const max = toolName && TOOL_OUTPUT_LIMITS[toolName] !== undefined
+        ? TOOL_OUTPUT_LIMITS[toolName]
+        : DEFAULT_MAX_TOOL_OUTPUT_LINES;
+    // Reserve at least 1 head + 1 tail line so the user can see the
+    // shape of the truncation; rest is head-weighted (where the
+    // interesting content usually is).
+    const tailLines = max >= 8 ? 3 : 2;
+    const headLines = Math.max(1, max - tailLines - 1);
+    const lines = text.split("\n");
+    if (color === "red" || lines.length <= max) {
+        return _jsx(WrappedLines, { text: text, width: width, keyPrefix: keyPrefix, color: color });
+    }
+    const head = lines.slice(0, headLines).join("\n");
+    const tail = lines.slice(lines.length - tailLines).join("\n");
+    const hidden = lines.length - headLines - tailLines;
+    return (_jsxs(_Fragment, { children: [_jsx(WrappedLines, { text: head, width: width, keyPrefix: `${keyPrefix}-h`, color: color }), _jsx(Text, { dimColor: true, children: `… ${hidden} line${hidden === 1 ? "" : "s"} hidden …` }), _jsx(WrappedLines, { text: tail, width: width, keyPrefix: `${keyPrefix}-t`, color: color })] }));
+}
 /**
  * Render text as N <Text> elements, one per pre-wrapped line. Stacks
  * vertically inside the parent column-flex Box. Pre-wrap means the
@@ -59,12 +424,36 @@ function WrappedLines({ text, width, keyPrefix, color, dimColor, italic }) {
         // biome-ignore lint/suspicious/noArrayIndexKey: stateless leaf, reuse is safe
         _jsx(Text, { color: color, dimColor: dimColor, italic: italic, children: line.length === 0 ? " " : line }, `${keyPrefix}:${i}`))) }));
 }
-function renderUserContent(content) {
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .map((block) => block.type === "text" ? (block.text ?? "") : `[image:${block.mimeType ?? "?"}]`)
-        .join("");
+/**
+ * Render an array-content user message — typically text + one or more
+ * image attachments. Text blocks pass through `WrappedLines`; image
+ * blocks render as a dim "image (PNG, 142 KB)" line so the user can
+ * see at a glance that an image was sent.
+ */
+function UserBlocks({ blocks, width }) {
+    if (!Array.isArray(blocks))
+        return null;
+    const rows = [];
+    for (let i = 0; i < blocks.length; i++) {
+        const b = blocks[i];
+        if (b.type === "text" && b.text) {
+            rows.push(_jsx(WrappedLines, { text: b.text, width: width, keyPrefix: `u-t-${i}` }, `u-t-${i}`));
+            continue;
+        }
+        if (b.type === "image") {
+            const subtype = (b.mimeType ?? "image/?").split("/")[1]?.toUpperCase() ?? "?";
+            const size = b.data ? formatBytes(Math.floor((b.data.length * 3) / 4)) : "";
+            rows.push(_jsxs(Text, { dimColor: true, children: ["\uD83D\uDCF7 image (", subtype, size ? `, ${size}` : "", ")"] }, `u-i-${i}`));
+        }
+    }
+    return _jsx(_Fragment, { children: rows });
+}
+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`;
 }
 /**
  * Stable key per assistant content block. Tool calls have an id; text and
@@ -86,4 +475,194 @@ function summarizeArgs(args) {
     })
         .join(", ");
 }
+/**
+ * Render a tool call as a human-friendly action label, the way Claude
+ * Code formats them: present-tense verb + the salient argument
+ * (file path, command, URL, search query, etc.) instead of the raw
+ * `toolName(k1=v1, k2=v2)` shape. Falls back to the verbose form for
+ * tools we don't have a special case for.
+ */
+function toolActionLabel(name, args) {
+    const a = (args ?? {});
+    const str = (k) => (typeof a[k] === "string" ? a[k] : "");
+    const path = displayPath(str("path") || str("file_path"));
+    switch (name) {
+        case "read_file":
+            return `Reading ${path}`;
+        case "write_file":
+            return `Writing ${path}`;
+        case "edit_file":
+            return `Editing ${path}`;
+        case "multi_edit":
+            return `Editing ${path}`;
+        case "notebook_edit":
+            return `Editing notebook ${path}`;
+        case "list_files":
+            return `Listing ${path || "."}`;
+        case "glob":
+            return `Searching ${str("pattern")}`;
+        case "grep":
+            return `Searching for "${str("pattern")}"`;
+        case "shell":
+            return `Running: ${truncate(str("command") || str("cmd"), 60)}`;
+        case "web_fetch":
+            return `Fetching ${str("url")}`;
+        case "web_search":
+            return `Searching: ${truncate(str("query"), 60)}`;
+        case "git_status":
+            return "git status";
+        case "git_diff":
+            return `git diff${str("target") ? ` ${str("target")}` : ""}`;
+        case "git_log":
+            return "git log";
+        case "git_commit":
+            return `git commit: ${truncate(str("message"), 50)}`;
+        case "git_branch":
+            return str("name") ? `git branch ${str("name")}` : "git branches";
+        case "enter_worktree":
+            return `Entering worktree ${str("branch") || str("name")}`;
+        case "exit_worktree":
+            return "Leaving worktree";
+        case "enter_plan_mode":
+            return "Entering plan mode";
+        case "exit_plan_mode":
+            return "Exiting plan mode";
+        case "dispatch_agent":
+            return `Dispatching subagent: ${truncate(str("task"), 60)}`;
+        case "ask_user":
+            return `Asking: ${truncate(str("question"), 60)}`;
+        case "create_task":
+            return `Task: ${truncate(str("subject"), 60)}`;
+        case "update_task":
+            return `Updating task ${str("taskId")}`;
+        case "list_tasks":
+            return "Listing tasks";
+        case "get_task":
+            return `Reading task ${str("taskId")}`;
+        case "save_memory":
+            return `Saving memory: ${str("name") || str("type")}`;
+        case "read_memory":
+            return str("filename") ? `Reading memory ${str("filename")}` : "Reading MEMORY.md";
+        case "config":
+            return str("path") ? `config(${str("path")})` : "Reading config";
+        default:
+            return `${name}(${summarizeArgs(args)})`;
+    }
+}
+function truncate(s, n) {
+    if (s.length <= n)
+        return s;
+    return `${s.slice(0, n - 1)}…`;
+}
+/**
+ * Show a path relative to the working directory when it's inside (so
+ * "src/ui/Message.tsx" instead of "/home/half/.../src/ui/Message.tsx"),
+ * but keep it absolute when it points outside the project — that's
+ * useful information the user should see at full fidelity. Empty
+ * strings pass through unchanged.
+ */
+function displayPath(p) {
+    if (!p)
+        return p;
+    const visible = makeRelative(p);
+    return hyperlinkPath(visible, p);
+}
+function makeRelative(p) {
+    if (!p.startsWith(pathSep))
+        return p; // already relative
+    const cwd = process.cwd();
+    const rel = relativePath(cwd, p);
+    if (!rel || rel.startsWith(".."))
+        return p; // outside cwd — keep absolute
+    return rel;
+}
+/**
+ * Wrap a visible path in an OSC 8 hyperlink so terminals that support
+ * it (Ghostty, iTerm2, Kitty, recent gnome-terminal) make file paths
+ * clickable — click opens the file in $EDITOR / the OS default. The
+ * escape is zero-width and well-handled by wrap-ansi for width calc.
+ * Terminals that don't recognise OSC 8 silently strip it, so the
+ * fallback is just "non-clickable plain text" — no visible breakage.
+ * Opt-out: NO_HYPERLINK=1 (FORCE_HYPERLINK is honoured the other way,
+ * matching the common npm `supports-hyperlinks` convention).
+ */
+function hyperlinkPath(visible, rawPath) {
+    if (process.env.NO_HYPERLINK === "1")
+        return visible;
+    const absolute = isAbsolute(rawPath) ? rawPath : resolveAbsolute(process.cwd(), rawPath);
+    const url = `file://${absolute.split(pathSep).map(encodeURIComponent).join("/")}`;
+    return `\x1b]8;;${url}\x1b\\${visible}\x1b]8;;\x1b\\`;
+}
+/**
+ * Past-tense action label, used when a tool has finished. Same shape
+ * as `toolActionLabel` but with the verbs swapped to past tense:
+ * "Reading X" → "Read X", "Editing Y" → "Edited Y", etc.
+ */
+function toolActionPast(name, args) {
+    const a = (args ?? {});
+    const str = (k) => (typeof a[k] === "string" ? a[k] : "");
+    const path = displayPath(str("path") || str("file_path"));
+    switch (name) {
+        case "read_file":
+            return `Read ${path}`;
+        case "write_file":
+            return `Wrote ${path}`;
+        case "edit_file":
+            return `Edited ${path}`;
+        case "multi_edit":
+            return `Edited ${path}`;
+        case "notebook_edit":
+            return `Edited notebook ${path}`;
+        case "list_files":
+            return `Listed ${path || "."}`;
+        case "glob":
+            return `Searched ${str("pattern")}`;
+        case "grep":
+            return `Searched for "${str("pattern")}"`;
+        case "shell":
+            return `Ran: ${truncate(str("command") || str("cmd"), 60)}`;
+        case "web_fetch":
+            return `Fetched ${str("url")}`;
+        case "web_search":
+            return `Searched: ${truncate(str("query"), 60)}`;
+        case "git_status":
+            return "git status";
+        case "git_diff":
+            return `git diff${str("target") ? ` ${str("target")}` : ""}`;
+        case "git_log":
+            return "git log";
+        case "git_commit":
+            return `git commit: ${truncate(str("message"), 50)}`;
+        case "git_branch":
+            return str("name") ? `git branch ${str("name")}` : "git branches";
+        case "enter_worktree":
+            return `Entered worktree ${str("branch") || str("name")}`;
+        case "exit_worktree":
+            return "Left worktree";
+        case "enter_plan_mode":
+            return "Entered plan mode";
+        case "exit_plan_mode":
+            return "Exited plan mode";
+        case "dispatch_agent":
+            return `Subagent: ${truncate(str("task"), 60)}`;
+        case "ask_user":
+            return `Asked: ${truncate(str("question"), 60)}`;
+        case "create_task":
+            return `Created task: ${truncate(str("subject"), 60)}`;
+        case "update_task":
+            return `Updated task ${str("taskId")}`;
+        case "list_tasks":
+            return "Listed tasks";
+        case "get_task":
+            return `Read task ${str("taskId")}`;
+        case "save_memory":
+            return `Saved memory: ${str("name") || str("type")}`;
+        case "read_memory":
+            return str("filename") ? `Read memory ${str("filename")}` : "Read MEMORY.md";
+        case "config":
+            return str("path") ? `config(${str("path")})` : "Read config";
+        default:
+            return `${name}(${summarizeArgs(args)})`;
+    }
+}
 //# sourceMappingURL=Message.js.map