agent-sh 0.8.0 → 0.10.0

package/dist/utils/line-editor.js

@@ -2,22 +2,110 @@
  * Minimal line editor with readline-style keybindings.
  *
  * Pure logic — no I/O, no rendering, no event bus. Consumers feed raw
- * terminal input bytes and receive high-level actions back. Buffer and
- * cursor state are public for rendering.
+ * terminal input bytes and receive high-level actions back.
+ *
+ * The internal buffer may contain PUA placeholder characters for pasted
+ * multi-line content. Consumers should use the typed accessors:
+ *   - `text`          — resolved content (pastes expanded), for submit/history/logic
+ *   - `displayText`   — display content (pastes collapsed to labels), for rendering
+ *   - `displayCursor` — cursor column in display coordinates
+ *   - `setText()`     — replace buffer content (clears paste attachments)
  */
+import { charWidth } from "./ansi.js";
 // ── Kitty protocol keycode → readable name ──────────────────────
 const KITTY_KEY_NAMES = {
     9: "tab", 13: "enter", 27: "escape", 127: "backspace",
 };
+// ── Paste placeholder ───────────────────────────────────────────
+/** First Unicode Private Use Area codepoint, used as paste placeholder. */
+const PUA_BASE = 0xE000;
+function isPUA(ch) {
+    const code = ch.charCodeAt(0);
+    return code >= PUA_BASE && code <= 0xF8FF;
+}
 // ── Line editor ─────────────────────────────────────────────────
 export class LineEditor {
-    buffer = "";
+    _buf = "";
     cursor = 0;
     pendingSeq = ""; // buffered incomplete escape sequence
+    // ── Bracket paste state ─────────────────────────────────────
+    inPaste = false;
+    pasteAccum = ""; // accumulates during bracket paste
+    pastes = new Map(); // id → pasted content
+    pasteCounter = 0;
     // ── History ──────────────────────────────────────────────────
     history = [];
     historyIndex = -1; // -1 = current input, 0..N = history entries (newest first)
     savedBuffer = ""; // saves current input when browsing history
+    // ── Public accessors ────────────────────────────────────────
+    /** Resolved text — paste placeholders expanded. For submit, history, logic. */
+    get text() {
+        let result = "";
+        for (const ch of this._buf) {
+            const paste = this.pastes.get(ch.charCodeAt(0) - PUA_BASE);
+            result += paste ?? ch;
+        }
+        return result;
+    }
+    /** Display text — paste placeholders replaced with labels. For rendering. */
+    get displayText() {
+        let result = "";
+        for (const ch of this._buf) {
+            const paste = this.pastes.get(ch.charCodeAt(0) - PUA_BASE);
+            if (paste) {
+                const n = paste.split("\n").length;
+                result += `[paste +${n} lines]`;
+            }
+            else {
+                result += ch;
+            }
+        }
+        return result;
+    }
+    /** Cursor position mapped to display-text character offset. */
+    get displayCursor() {
+        let pos = 0;
+        for (let i = 0; i < this._buf.length && i < this.cursor; i++) {
+            const ch = this._buf[i];
+            const paste = this.pastes.get(ch.charCodeAt(0) - PUA_BASE);
+            if (paste) {
+                const n = paste.split("\n").length;
+                pos += `[paste +${n} lines]`.length;
+            }
+            else {
+                pos++;
+            }
+        }
+        return pos;
+    }
+    /** Cursor position as visible terminal-column width (accounts for CJK etc.). */
+    get displayCursorWidth() {
+        let width = 0;
+        for (let i = 0; i < this._buf.length && i < this.cursor; i++) {
+            const ch = this._buf[i];
+            const paste = this.pastes.get(ch.charCodeAt(0) - PUA_BASE);
+            if (paste) {
+                const n = paste.split("\n").length;
+                width += `[paste +${n} lines]`.length; // ASCII-only, 1 col each
+            }
+            else {
+                width += charWidth(ch.codePointAt(0) ?? 0);
+            }
+        }
+        return width;
+    }
+    /** Number of logical positions in the buffer. */
+    get length() {
+        return this._buf.length;
+    }
+    /** Replace buffer content. Clears paste attachments. */
+    setText(value) {
+        this._buf = value;
+        this.pastes.clear();
+        this.pasteCounter = 0;
+        this.cursor = value.length;
+    }
+    // ── Input processing ────────────────────────────────────────
     /** Process raw terminal input, return actions for the consumer. */
     feed(data) {
         // If we had a pending incomplete escape sequence, prepend it
@@ -68,7 +156,7 @@ export class LineEditor {
                             actions.push({ action: "arrow-down" });
                             break;
                         case "C":
-                            if (this.cursor < this.buffer.length) {
+                            if (this.cursor < this._buf.length) {
                                 this.cursor++;
                                 actions.push({ action: "changed" });
                             }
@@ -86,8 +174,8 @@ export class LineEditor {
                             }
                             break;
                         case "F": // End
-                            if (this.cursor < this.buffer.length) {
-                                this.cursor = this.buffer.length;
+                            if (this.cursor < this._buf.length) {
+                                this.cursor = this._buf.length;
                                 actions.push({ action: "changed" });
                             }
                             break;
@@ -119,6 +207,16 @@ export class LineEditor {
                 // Other Alt+key — ignore
                 continue;
             }
+            // ── Bracket paste: accumulate into side buffer ─────
+            if (this.inPaste) {
+                if (ch === "\r") {
+                    i++;
+                    continue;
+                } // skip CR (CR+LF → just LF)
+                this.pasteAccum += ch;
+                i++;
+                continue;
+            }
             // ── Control characters ──────────────────────────────
             if (ch.charCodeAt(0) < 0x20 || ch === "\x7f") {
                 const action = this.handleControl(ch);
@@ -128,7 +226,7 @@ export class LineEditor {
                 continue;
             }
             // ── Printable character ─────────────────────────────
-            this.buffer = this.buffer.slice(0, this.cursor) + ch + this.buffer.slice(this.cursor);
+            this._buf = this._buf.slice(0, this.cursor) + ch + this._buf.slice(this.cursor);
             this.cursor++;
             actions.push({ action: "changed" });
             i++;
@@ -148,9 +246,13 @@ export class LineEditor {
         return wasBarEscape ? [{ action: "cancel" }] : [];
     }
     clear() {
-        this.buffer = "";
+        this._buf = "";
         this.cursor = 0;
         this.pendingSeq = "";
+        this.inPaste = false;
+        this.pasteAccum = "";
+        this.pastes.clear();
+        this.pasteCounter = 0;
         this.historyIndex = -1;
         this.savedBuffer = "";
     }
@@ -171,11 +273,10 @@ export class LineEditor {
         if (this.historyIndex + 1 >= this.history.length)
             return null;
         if (this.historyIndex === -1) {
-            this.savedBuffer = this.buffer; // save current input
+            this.savedBuffer = this.text; // save resolved current input
         }
         this.historyIndex++;
-        this.buffer = this.history[this.historyIndex];
-        this.cursor = this.buffer.length;
+        this.setText(this.history[this.historyIndex]);
         return { action: "changed" };
     }
     /** Navigate to a more recent history entry. Returns changed action or null. */
@@ -184,12 +285,11 @@ export class LineEditor {
             return null;
         this.historyIndex--;
         if (this.historyIndex === -1) {
-            this.buffer = this.savedBuffer;
+            this.setText(this.savedBuffer);
         }
         else {
-            this.buffer = this.history[this.historyIndex];
+            this.setText(this.history[this.historyIndex]);
         }
-        this.cursor = this.buffer.length;
         return { action: "changed" };
     }
     // ── Key bindings ────────────────────────────────────────────
@@ -198,17 +298,17 @@ export class LineEditor {
     // characters and kitty protocol sequences resolve to a key name
     // and look it up here. To add a binding, add one entry.
     bindings = {
-        "enter": () => ({ action: "submit", buffer: this.buffer }),
+        "enter": () => ({ action: "submit", buffer: this.text }),
         "ctrl+c": () => ({ action: "cancel" }),
         "tab": () => ({ action: "tab" }),
         "backspace": () => this.deleteBackward(),
-        "ctrl+d": () => this.buffer.length === 0 ? { action: "delete-empty" } : this.deleteForward(),
-        "ctrl+a": () => this.moveTo(0),
-        "ctrl+e": () => this.moveTo(this.buffer.length),
+        "ctrl+d": () => this._buf.length === 0 ? { action: "delete-empty" } : this.deleteForward(),
+        "ctrl+a": () => this.moveToLineStart(),
+        "ctrl+e": () => this.moveToLineEnd(),
         "ctrl+b": () => this.moveTo(this.cursor - 1),
         "ctrl+f": () => this.moveTo(this.cursor + 1),
-        "ctrl+u": () => this.deleteRange(0, this.cursor),
-        "ctrl+k": () => this.deleteRange(this.cursor, this.buffer.length),
+        "ctrl+u": () => this.deleteLineStart(),
+        "ctrl+k": () => this.deleteLineEnd(),
         "ctrl+w": () => this.deleteWordBackward() ? { action: "changed" } : null,
         "alt+f": () => this.wordForward() ? { action: "changed" } : null,
         "alt+b": () => this.wordBackward() ? { action: "changed" } : null,
@@ -259,36 +359,73 @@ export class LineEditor {
     }
     // ── Editing primitives ─────────────────────────────────────
     insertAt(ch) {
-        this.buffer = this.buffer.slice(0, this.cursor) + ch + this.buffer.slice(this.cursor);
+        this._buf = this._buf.slice(0, this.cursor) + ch + this._buf.slice(this.cursor);
         this.cursor++;
         return { action: "changed" };
     }
     moveTo(pos) {
-        const clamped = Math.max(0, Math.min(pos, this.buffer.length));
+        const clamped = Math.max(0, Math.min(pos, this._buf.length));
         if (clamped === this.cursor)
             return null;
         this.cursor = clamped;
         return { action: "changed" };
     }
+    /** Move cursor to start of the current logical line. */
+    moveToLineStart() {
+        const lineStart = this._buf.lastIndexOf("\n", this.cursor - 1) + 1;
+        return this.moveTo(lineStart);
+    }
+    /** Move cursor to end of the current logical line. */
+    moveToLineEnd() {
+        const nextNewline = this._buf.indexOf("\n", this.cursor);
+        const lineEnd = nextNewline === -1 ? this._buf.length : nextNewline;
+        return this.moveTo(lineEnd);
+    }
+    /** Delete from start of current logical line to cursor (Ctrl+U). */
+    deleteLineStart() {
+        const lineStart = this._buf.lastIndexOf("\n", this.cursor - 1) + 1;
+        return this.deleteRange(lineStart, this.cursor);
+    }
+    /** Delete from cursor to end of current logical line (Ctrl+K). */
+    deleteLineEnd() {
+        const nextNewline = this._buf.indexOf("\n", this.cursor);
+        const lineEnd = nextNewline === -1 ? this._buf.length : nextNewline;
+        return this.deleteRange(this.cursor, lineEnd);
+    }
     deleteBackward() {
-        if (this.buffer.length === 0)
+        if (this._buf.length === 0)
             return { action: "delete-empty" };
         if (this.cursor <= 0)
             return null;
-        this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+        // If deleting a paste placeholder, also remove the paste entry
+        const deleted = this._buf[this.cursor - 1];
+        if (isPUA(deleted)) {
+            this.pastes.delete(deleted.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, this.cursor - 1) + this._buf.slice(this.cursor);
         this.cursor--;
         return { action: "changed" };
     }
     deleteForward() {
-        if (this.cursor >= this.buffer.length)
+        if (this.cursor >= this._buf.length)
             return null;
-        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+        const deleted = this._buf[this.cursor];
+        if (isPUA(deleted)) {
+            this.pastes.delete(deleted.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, this.cursor) + this._buf.slice(this.cursor + 1);
         return { action: "changed" };
     }
     deleteRange(start, end) {
         if (start >= end)
             return null;
-        this.buffer = this.buffer.slice(0, start) + this.buffer.slice(end);
+        // Clean up any paste entries in the deleted range
+        for (let k = start; k < end; k++) {
+            const ch = this._buf[k];
+            if (isPUA(ch))
+                this.pastes.delete(ch.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, start) + this._buf.slice(end);
         this.cursor = start;
         return { action: "changed" };
     }
@@ -326,7 +463,7 @@ export class LineEditor {
                         actions.push({ action: "changed" });
                 }
                 else {
-                    if (this.cursor < this.buffer.length) {
+                    if (this.cursor < this._buf.length) {
                         this.cursor++;
                         actions.push({ action: "changed" });
                     }
@@ -351,8 +488,8 @@ export class LineEditor {
                 }
                 break;
             case "F": // End
-                if (this.cursor < this.buffer.length) {
-                    this.cursor = this.buffer.length;
+                if (this.cursor < this._buf.length) {
+                    this.cursor = this._buf.length;
                     actions.push({ action: "changed" });
                 }
                 break;
@@ -365,11 +502,39 @@ export class LineEditor {
                     actions.push(action);
                 break;
             }
-            case "~": // Extended keys: Delete (3~), etc.
+            case "~": // Extended keys: Delete (3~), bracket paste (200~/201~), etc.
                 if (params === "3") {
                     // Delete key: delete char under cursor
-                    if (this.cursor < this.buffer.length) {
-                        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+                    if (this.cursor < this._buf.length) {
+                        const deleted = this._buf[this.cursor];
+                        if (isPUA(deleted))
+                            this.pastes.delete(deleted.charCodeAt(0) - PUA_BASE);
+                        this._buf = this._buf.slice(0, this.cursor) + this._buf.slice(this.cursor + 1);
+                        actions.push({ action: "changed" });
+                    }
+                }
+                else if (params === "200") {
+                    this.inPaste = true;
+                    this.pasteAccum = "";
+                }
+                else if (params === "201") {
+                    this.inPaste = false;
+                    if (this.pasteAccum) {
+                        const lines = this.pasteAccum.split("\n");
+                        if (lines.length <= 1) {
+                            // Single-line paste — inline directly
+                            this._buf = this._buf.slice(0, this.cursor) + this.pasteAccum + this._buf.slice(this.cursor);
+                            this.cursor += this.pasteAccum.length;
+                        }
+                        else {
+                            // Multi-line paste — store and insert placeholder
+                            const id = this.pasteCounter++;
+                            this.pastes.set(id, this.pasteAccum);
+                            const placeholder = String.fromCharCode(PUA_BASE + id);
+                            this._buf = this._buf.slice(0, this.cursor) + placeholder + this._buf.slice(this.cursor);
+                            this.cursor++;
+                        }
+                        this.pasteAccum = "";
                         actions.push({ action: "changed" });
                     }
                 }
@@ -383,11 +548,11 @@ export class LineEditor {
         if (this.cursor === 0)
             return false;
         let pos = this.cursor;
-        // Skip spaces
-        while (pos > 0 && this.buffer[pos - 1] === " ")
+        // Skip PUA placeholders and spaces
+        while (pos > 0 && (this._buf[pos - 1] === " " || isPUA(this._buf[pos - 1])))
             pos--;
         // Skip word chars
-        while (pos > 0 && this.buffer[pos - 1] !== " ")
+        while (pos > 0 && this._buf[pos - 1] !== " " && !isPUA(this._buf[pos - 1]))
             pos--;
         if (pos === this.cursor)
             return false;
@@ -395,14 +560,14 @@ export class LineEditor {
         return true;
     }
     wordForward() {
-        if (this.cursor >= this.buffer.length)
+        if (this.cursor >= this._buf.length)
             return false;
         let pos = this.cursor;
-        // Skip word chars
-        while (pos < this.buffer.length && this.buffer[pos] !== " ")
+        // Skip word chars and PUA placeholders
+        while (pos < this._buf.length && this._buf[pos] !== " " && !isPUA(this._buf[pos]))
             pos++;
-        // Skip spaces
-        while (pos < this.buffer.length && this.buffer[pos] === " ")
+        // Skip spaces and PUA
+        while (pos < this._buf.length && (this._buf[pos] === " " || isPUA(this._buf[pos])))
             pos++;
         if (pos === this.cursor)
             return false;
@@ -414,15 +579,27 @@ export class LineEditor {
             return false;
         const start = this.cursor;
         this.wordBackward();
-        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(start);
+        // Clean up paste entries
+        for (let k = this.cursor; k < start; k++) {
+            const ch = this._buf[k];
+            if (isPUA(ch))
+                this.pastes.delete(ch.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, this.cursor) + this._buf.slice(start);
         return true;
     }
     deleteWordForward() {
-        if (this.cursor >= this.buffer.length)
+        if (this.cursor >= this._buf.length)
             return false;
         const start = this.cursor;
         this.wordForward();
-        this.buffer = this.buffer.slice(0, start) + this.buffer.slice(this.cursor);
+        // Clean up paste entries
+        for (let k = start; k < this.cursor; k++) {
+            const ch = this._buf[k];
+            if (isPUA(ch))
+                this.pastes.delete(ch.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, start) + this._buf.slice(this.cursor);
         this.cursor = start;
         return true;
     }

package/dist/utils/markdown.d.ts

@@ -1,3 +1,4 @@
+export declare const MAX_CONTENT_WIDTH = 90;
 /**
  * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
  * Returns an array of lines, each fitting within `maxWidth` visible characters.

package/dist/utils/markdown.js

@@ -1,6 +1,6 @@
 import { visibleLen, truncateToWidth, padEndToWidth } from "./ansi.js";
 import { palette as p } from "./palette.js";
-const MAX_CONTENT_WIDTH = 90;
+export const MAX_CONTENT_WIDTH = 90;
 /**
  * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
  * Returns an array of lines, each fitting within `maxWidth` visible characters.

package/dist/utils/message-utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Utilities for manipulating OpenAI-format message arrays.
+ *
+ * Used by extensions advising `conversation:prepare` to transform
+ * the message array before it's sent to the LLM.
+ */
+/**
+ * Find tool call IDs matching a tool name and optional argument filter.
+ *
+ * Scans assistant messages for tool_calls where `function.name` matches
+ * and parsed arguments satisfy the filter (shallow key/value match).
+ *
+ * Returns call IDs in message order (earliest first).
+ */
+export declare function findToolCallIds(messages: any[], toolName: string, argFilter?: Record<string, unknown>): string[];
+/**
+ * Replace tool result content for specific call IDs.
+ *
+ * Returns a new array (shallow copy) with matching tool messages
+ * replaced. Non-matching messages are passed through by reference.
+ */
+export declare function stubToolResults(messages: any[], callIds: Set<string>, stub: string): any[];
+/**
+ * Deduplicate tool results: keep only the latest result for a given
+ * tool name + argument filter, replace all older results with a stub.
+ *
+ * Common use case: a file that's read repeatedly (e.g. a live transcript)
+ * — only the most recent read matters.
+ *
+ * Example:
+ *   dedupeToolResults(messages, "read_file",
+ *     { path: "/path/to/transcript.txt" },
+ *     "[stale — superseded by later read]")
+ */
+export declare function dedupeToolResults(messages: any[], toolName: string, argFilter?: Record<string, unknown>, stub?: string): any[];

package/dist/utils/message-utils.js

@@ -0,0 +1,75 @@
+/**
+ * Utilities for manipulating OpenAI-format message arrays.
+ *
+ * Used by extensions advising `conversation:prepare` to transform
+ * the message array before it's sent to the LLM.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Find tool call IDs matching a tool name and optional argument filter.
+ *
+ * Scans assistant messages for tool_calls where `function.name` matches
+ * and parsed arguments satisfy the filter (shallow key/value match).
+ *
+ * Returns call IDs in message order (earliest first).
+ */
+export function findToolCallIds(messages, toolName, argFilter) {
+    const ids = [];
+    for (const msg of messages) {
+        if (msg.role !== "assistant" || !msg.tool_calls)
+            continue;
+        for (const tc of msg.tool_calls) {
+            const fn = tc.function ?? tc.fn;
+            if (!fn || fn.name !== toolName)
+                continue;
+            if (argFilter) {
+                let args;
+                try {
+                    args = JSON.parse(fn.arguments);
+                }
+                catch {
+                    continue;
+                }
+                const match = Object.entries(argFilter).every(([k, v]) => args[k] === v);
+                if (!match)
+                    continue;
+            }
+            ids.push(tc.id);
+        }
+    }
+    return ids;
+}
+/**
+ * Replace tool result content for specific call IDs.
+ *
+ * Returns a new array (shallow copy) with matching tool messages
+ * replaced. Non-matching messages are passed through by reference.
+ */
+export function stubToolResults(messages, callIds, stub) {
+    return messages.map((msg) => {
+        if (msg.role === "tool" && callIds.has(msg.tool_call_id)) {
+            return { ...msg, content: stub };
+        }
+        return msg;
+    });
+}
+/**
+ * Deduplicate tool results: keep only the latest result for a given
+ * tool name + argument filter, replace all older results with a stub.
+ *
+ * Common use case: a file that's read repeatedly (e.g. a live transcript)
+ * — only the most recent read matters.
+ *
+ * Example:
+ *   dedupeToolResults(messages, "read_file",
+ *     { path: "/path/to/transcript.txt" },
+ *     "[stale — superseded by later read]")
+ */
+export function dedupeToolResults(messages, toolName, argFilter, stub = "[superseded by later call]") {
+    const callIds = findToolCallIds(messages, toolName, argFilter);
+    if (callIds.length <= 1)
+        return messages;
+    // Keep the last one, stub the rest
+    const staleIds = new Set(callIds.slice(0, -1));
+    return stubToolResults(messages, staleIds, stub);
+}

package/dist/utils/terminal-buffer.d.ts

@@ -47,7 +47,9 @@ export declare class TerminalBuffer {
     /** Get the raw serialized terminal output (includes ANSI sequences). */
     serialize(): string;
     /** Read clean screen text with metadata. */
-    readScreen(): ScreenSnapshot;
+    readScreen(opts?: {
+        includeScrollback?: boolean;
+    }): ScreenSnapshot;
     /**
      * Get terminal screen as lines, padded/trimmed to exactly `rows` lines.
      * Clean text only (ANSI stripped).  Reads from the active buffer's
@@ -57,6 +59,8 @@ export declare class TerminalBuffer {
     getScreenLines(rows?: number): string[];
     /** Read visible viewport lines from a buffer. */
     private readViewportLines;
+    /** Read all lines including scrollback from a buffer. */
+    private readAllLines;
     /** Get cursor position. */
     getCursor(): {
         x: number;

package/dist/utils/terminal-buffer.js

@@ -130,9 +130,11 @@ export class TerminalBuffer {
         return this.serializeAddon.serialize();
     }
     /** Read clean screen text with metadata. */
-    readScreen() {
+    readScreen(opts) {
         const buf = this.term.buffer.active;
-        const lines = this.readViewportLines(buf);
+        const lines = opts?.includeScrollback
+            ? this.readAllLines(buf)
+            : this.readViewportLines(buf);
         return {
             text: lines.join("\n"),
             altScreen: buf.type === "alternate",
@@ -161,6 +163,20 @@ export class TerminalBuffer {
         }
         return lines;
     }
+    /** Read all lines including scrollback from a buffer. */
+    readAllLines(buf) {
+        const total = (buf.baseY ?? 0) + buf.length;
+        const lines = [];
+        for (let y = 0; y < total; y++) {
+            const line = buf.getLine(y);
+            lines.push(line ? line.translateToString(true) : "");
+        }
+        // Trim trailing empty lines
+        while (lines.length > 0 && lines[lines.length - 1] === "") {
+            lines.pop();
+        }
+        return lines;
+    }
     /** Get cursor position. */
     getCursor() {
         return {

package/dist/utils/tool-display.d.ts

@@ -27,7 +27,7 @@ export interface ToolResultRender {
 }
 export declare function isQuietCommand(command: string): boolean;
 export declare function selectToolDisplayMode(width: number): ToolDisplayMode;
-export declare function renderToolCall(tool: ToolCallRender, width: number): string[];
+export declare function renderToolCall(tool: ToolCallRender, width: number, cwd?: string): string[];
 export declare function renderToolResult(result: ToolResultRender, width: number): string[];
 export declare function formatElapsed(ms: number): string;
 export declare const SPINNER_FRAMES: string[];

package/dist/utils/tool-display.js

@@ -39,7 +39,6 @@ const KIND_ICONS = {
     move: "↗",
     search: "⌕",
     execute: "▶",
-    display: "◇",
     think: "◇",
     fetch: "↓",
     switch_mode: "⇄",
@@ -48,7 +47,7 @@ function kindIcon(kind) {
     return kind ? (KIND_ICONS[kind] ?? "▶") : "▶";
 }
 // ── Tool call rendering ──────────────────────────────────────────
-export function renderToolCall(tool, width) {
+export function renderToolCall(tool, width, cwd = process.cwd()) {
     const mode = selectToolDisplayMode(width);
     const icon = tool.icon ?? kindIcon(tool.kind);
     // If the tool registered a custom icon, it's self-describing — omit the name.
@@ -61,7 +60,6 @@ export function renderToolCall(tool, width) {
     const lines = [];
     // Build a compact detail string to append after the title
     let detail = "";
-    const cwd = process.cwd();
     if (mode === "full" && tool.displayDetail) {
         detail = tool.displayDetail;
     }
@@ -70,7 +68,7 @@ export function renderToolCall(tool, width) {
             detail = `$ ${tool.command}`;
         }
         else if (tool.locations && tool.locations.length > 0) {
-            const loc = tool.locations[0];
+            const loc = tool.locations.find((l) => l?.path) ?? tool.locations[0];
             const lineInfo = loc.line ? `:${loc.line}` : "";
             detail = `${shortenPath(loc.path, cwd)}${lineInfo}`;
         }
@@ -227,6 +225,8 @@ export function renderSpinnerLine(state, label, opts) {
  * Shorten an absolute path to a relative or tilde-prefixed form.
  */
 function shortenPath(p, cwd) {
+    if (!p || typeof p !== "string")
+        return "";
     if (p.startsWith(cwd + "/"))
         return p.slice(cwd.length + 1);
     if (p.startsWith(cwd))