agent-sh 0.1.0 → 0.3.0

package/dist/utils/line-editor.js

@@ -0,0 +1,381 @@
+/**
+ * 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.
+ */
+// ── Kitty protocol keycode → readable name ──────────────────────
+const KITTY_KEY_NAMES = {
+    9: "tab", 13: "enter", 27: "escape", 127: "backspace",
+};
+// ── Line editor ─────────────────────────────────────────────────
+export class LineEditor {
+    buffer = "";
+    cursor = 0;
+    pendingSeq = ""; // buffered incomplete escape sequence
+    /** Process raw terminal input, return actions for the consumer. */
+    feed(data) {
+        // If we had a pending incomplete escape sequence, prepend it
+        if (this.pendingSeq) {
+            data = this.pendingSeq + data;
+            this.pendingSeq = "";
+        }
+        const actions = [];
+        let i = 0;
+        while (i < data.length) {
+            const ch = data[i];
+            // ── Escape sequences ────────────────────────────────
+            if (ch === "\x1b") {
+                const next = data[i + 1];
+                // Incomplete escape — buffer and wait for next feed()
+                if (next == null) {
+                    this.pendingSeq = "\x1b";
+                    i++;
+                    continue;
+                }
+                // CSI sequence: \x1b[...
+                if (next === "[") {
+                    const { consumed, incomplete } = this.handleCSI(data, i, actions);
+                    if (incomplete) {
+                        this.pendingSeq = data.slice(i, i + consumed);
+                        i += consumed;
+                    }
+                    else {
+                        i += consumed;
+                    }
+                    continue;
+                }
+                // SS3 sequence: \x1bO... (application cursor mode — arrow keys, Home, End)
+                if (next === "O") {
+                    const ss3Final = data[i + 2];
+                    if (ss3Final == null) {
+                        // Incomplete — buffer for next feed()
+                        this.pendingSeq = data.slice(i, i + 2);
+                        i += 2;
+                        continue;
+                    }
+                    i += 3; // consume \x1b O <final>
+                    switch (ss3Final) {
+                        case "A":
+                            actions.push({ action: "arrow-up" });
+                            break;
+                        case "B":
+                            actions.push({ action: "arrow-down" });
+                            break;
+                        case "C":
+                            if (this.cursor < this.buffer.length) {
+                                this.cursor++;
+                                actions.push({ action: "changed" });
+                            }
+                            break;
+                        case "D":
+                            if (this.cursor > 0) {
+                                this.cursor--;
+                                actions.push({ action: "changed" });
+                            }
+                            break;
+                        case "H": // Home
+                            if (this.cursor > 0) {
+                                this.cursor = 0;
+                                actions.push({ action: "changed" });
+                            }
+                            break;
+                        case "F": // End
+                            if (this.cursor < this.buffer.length) {
+                                this.cursor = this.buffer.length;
+                                actions.push({ action: "changed" });
+                            }
+                            break;
+                    }
+                    continue;
+                }
+                // Alt/Option + key: \x1b followed by char
+                i += 2; // consume \x1b + next byte
+                if (next === "\x7f") {
+                    // Option+Backspace: delete word backward
+                    if (this.deleteWordBackward())
+                        actions.push({ action: "changed" });
+                }
+                else if (next === "b") {
+                    // Alt+B: word backward
+                    if (this.wordBackward())
+                        actions.push({ action: "changed" });
+                }
+                else if (next === "f") {
+                    // Alt+F: word forward
+                    if (this.wordForward())
+                        actions.push({ action: "changed" });
+                }
+                else if (next === "d") {
+                    // Alt+D: delete word forward
+                    if (this.deleteWordForward())
+                        actions.push({ action: "changed" });
+                }
+                // Other Alt+key — ignore
+                continue;
+            }
+            // ── Control characters ──────────────────────────────
+            if (ch.charCodeAt(0) < 0x20 || ch === "\x7f") {
+                const action = this.handleControl(ch);
+                if (action)
+                    actions.push(action);
+                i++;
+                continue;
+            }
+            // ── Printable character ─────────────────────────────
+            this.buffer = this.buffer.slice(0, this.cursor) + ch + this.buffer.slice(this.cursor);
+            this.cursor++;
+            actions.push({ action: "changed" });
+            i++;
+        }
+        return actions;
+    }
+    /** Check if there's a pending incomplete escape sequence. */
+    hasPendingEscape() {
+        return this.pendingSeq.length > 0;
+    }
+    /** Flush a pending sequence — treat bare \x1b as cancel, discard incomplete CSI. */
+    flushPendingEscape() {
+        if (!this.pendingSeq)
+            return [];
+        const wasBarEscape = this.pendingSeq === "\x1b";
+        this.pendingSeq = "";
+        return wasBarEscape ? [{ action: "cancel" }] : [];
+    }
+    clear() {
+        this.buffer = "";
+        this.cursor = 0;
+        this.pendingSeq = "";
+    }
+    // ── Key bindings ────────────────────────────────────────────
+    //
+    // Single source of truth for all keybindings. Both legacy control
+    // 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 }),
+        "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+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+w": () => this.deleteWordBackward() ? { action: "changed" } : null,
+        "shift+enter": () => this.insertAt("\n"),
+        "shift+tab": () => ({ action: "shift+tab" }),
+    };
+    /** Resolve a key name from the bindings table and execute it. */
+    dispatch(key) {
+        return this.bindings[key]?.() ?? null;
+    }
+    // ── Legacy control character mapping ───────────────────────
+    /** Map a legacy control character to a key name. */
+    static CTRL_MAP = {
+        "\r": "enter", "\x03": "ctrl+c", "\t": "tab",
+        "\x7f": "backspace", "\b": "backspace",
+        "\x01": "ctrl+a", "\x02": "ctrl+b", "\x04": "ctrl+d",
+        "\x05": "ctrl+e", "\x06": "ctrl+f", "\x0b": "ctrl+k",
+        "\x15": "ctrl+u", "\x17": "ctrl+w",
+    };
+    handleControl(ch) {
+        const key = LineEditor.CTRL_MAP[ch];
+        return key ? this.dispatch(key) : null;
+    }
+    // ── Kitty keyboard protocol ────────────────────────────────
+    /** Handle a kitty protocol CSI u sequence. Params format: "keycode;modifier". */
+    handleKittyKey(params) {
+        const [kc, mod] = params.split(";").map(Number);
+        const keycode = kc;
+        const mods = (mod ?? 1) - 1; // kitty modifier bits
+        // Build key name from modifier + keycode
+        const modNames = [];
+        if (mods & 4)
+            modNames.push("ctrl");
+        if (mods & 1)
+            modNames.push("shift");
+        if (mods & 2)
+            modNames.push("alt");
+        const keyName = KITTY_KEY_NAMES[keycode] ?? String.fromCharCode(keycode);
+        const fullName = [...modNames, keyName].join("+");
+        // Try exact binding first, then fall back to ctrl char mapping
+        return this.dispatch(fullName)
+            ?? ((mods & 4) && keycode >= 97 && keycode <= 122
+                ? this.dispatch(`ctrl+${String.fromCharCode(keycode)}`)
+                : null)
+            ?? (mods === 0 ? this.handleControl(String.fromCharCode(keycode)) : null);
+    }
+    // ── Editing primitives ─────────────────────────────────────
+    insertAt(ch) {
+        this.buffer = this.buffer.slice(0, this.cursor) + ch + this.buffer.slice(this.cursor);
+        this.cursor++;
+        return { action: "changed" };
+    }
+    moveTo(pos) {
+        const clamped = Math.max(0, Math.min(pos, this.buffer.length));
+        if (clamped === this.cursor)
+            return null;
+        this.cursor = clamped;
+        return { action: "changed" };
+    }
+    deleteBackward() {
+        if (this.buffer.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);
+        this.cursor--;
+        return { action: "changed" };
+    }
+    deleteForward() {
+        if (this.cursor >= this.buffer.length)
+            return null;
+        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.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);
+        this.cursor = start;
+        return { action: "changed" };
+    }
+    // ── CSI sequence handling ───────────────────────────────────
+    /**
+     * Parse and handle a CSI sequence (\x1b[...) starting at `start`.
+     * Returns the number of bytes consumed and whether the sequence was incomplete.
+     */
+    handleCSI(data, start, actions) {
+        // Skip \x1b[
+        let j = start + 2;
+        // Accumulate parameter bytes (0x20-0x3F: digits, semicolons, etc.)
+        let params = "";
+        while (j < data.length && data.charCodeAt(j) >= 0x20 && data.charCodeAt(j) < 0x40) {
+            params += data[j];
+            j++;
+        }
+        // If we ran out of data before the final byte, sequence is incomplete
+        if (j >= data.length) {
+            return { consumed: j - start, incomplete: true };
+        }
+        const final = data[j];
+        const consumed = j - start + 1;
+        // Dispatch on final byte
+        switch (final) {
+            case "A": // Up arrow
+                actions.push({ action: "arrow-up" });
+                break;
+            case "B": // Down arrow
+                actions.push({ action: "arrow-down" });
+                break;
+            case "C": // Right (or modified right: 1;3C, 1;5C = word right)
+                if (params.includes(";")) {
+                    if (this.wordForward())
+                        actions.push({ action: "changed" });
+                }
+                else {
+                    if (this.cursor < this.buffer.length) {
+                        this.cursor++;
+                        actions.push({ action: "changed" });
+                    }
+                }
+                break;
+            case "D": // Left (or modified left: 1;3D, 1;5D = word left)
+                if (params.includes(";")) {
+                    if (this.wordBackward())
+                        actions.push({ action: "changed" });
+                }
+                else {
+                    if (this.cursor > 0) {
+                        this.cursor--;
+                        actions.push({ action: "changed" });
+                    }
+                }
+                break;
+            case "H": // Home
+                if (this.cursor > 0) {
+                    this.cursor = 0;
+                    actions.push({ action: "changed" });
+                }
+                break;
+            case "F": // End
+                if (this.cursor < this.buffer.length) {
+                    this.cursor = this.buffer.length;
+                    actions.push({ action: "changed" });
+                }
+                break;
+            case "Z": // Shift+Tab (legacy CSI sequence)
+                actions.push({ action: "shift+tab" });
+                break;
+            case "u": { // Kitty keyboard protocol: \x1b[<keycode>;<modifier>u
+                const action = this.handleKittyKey(params);
+                if (action)
+                    actions.push(action);
+                break;
+            }
+            case "~": // Extended keys: Delete (3~), 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);
+                        actions.push({ action: "changed" });
+                    }
+                }
+                break;
+            // All other CSI sequences — silently ignored
+        }
+        return { consumed };
+    }
+    // ── Word movement / deletion helpers ────────────────────────
+    wordBackward() {
+        if (this.cursor === 0)
+            return false;
+        let pos = this.cursor;
+        // Skip spaces
+        while (pos > 0 && this.buffer[pos - 1] === " ")
+            pos--;
+        // Skip word chars
+        while (pos > 0 && this.buffer[pos - 1] !== " ")
+            pos--;
+        if (pos === this.cursor)
+            return false;
+        this.cursor = pos;
+        return true;
+    }
+    wordForward() {
+        if (this.cursor >= this.buffer.length)
+            return false;
+        let pos = this.cursor;
+        // Skip word chars
+        while (pos < this.buffer.length && this.buffer[pos] !== " ")
+            pos++;
+        // Skip spaces
+        while (pos < this.buffer.length && this.buffer[pos] === " ")
+            pos++;
+        if (pos === this.cursor)
+            return false;
+        this.cursor = pos;
+        return true;
+    }
+    deleteWordBackward() {
+        if (this.cursor === 0)
+            return false;
+        const start = this.cursor;
+        this.wordBackward();
+        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(start);
+        return true;
+    }
+    deleteWordForward() {
+        if (this.cursor >= this.buffer.length)
+            return false;
+        const start = this.cursor;
+        this.wordForward();
+        this.buffer = this.buffer.slice(0, start) + this.buffer.slice(this.cursor);
+        this.cursor = start;
+        return true;
+    }
+}

package/dist/utils/markdown.js

@@ -108,13 +108,13 @@ export class MarkdownRenderer {
         }
     }
     printTopBorder() {
-        const w = Math.min(this.contentWidth, 40);
-        process.stdout.write(`${p.dim}${p.accent}${"─".repeat(w)}${p.reset}\n`);
+        const termW = process.stdout.columns || 80;
+        process.stdout.write(`${p.dim}${p.accent}${"─".repeat(termW)}${p.reset}\n`);
         this.firstLine = true;
     }
     printBottomBorder() {
-        const w = Math.min(this.contentWidth, 40);
-        process.stdout.write(`${p.dim}${p.accent}${"─".repeat(w)}${p.reset}\n`);
+        const termW = process.stdout.columns || 80;
+        process.stdout.write(`${p.dim}${p.accent}${"─".repeat(termW)}${p.reset}\n`);
     }
     processBuffer() {
         const lines = this.buffer.split("\n");

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

@@ -4,6 +4,15 @@ export interface ToolCallRender {
     title: string;
     /** Optional command string for bash-like tools. */
     command?: string;
+    /** Tool kind from ACP (read, edit, execute, search, etc.). */
+    kind?: string;
+    /** File locations affected by the tool call. */
+    locations?: {
+        path: string;
+        line?: number | null;
+    }[];
+    /** Raw input parameters sent to the tool. */
+    rawInput?: unknown;
 }
 export interface ToolResultRender {
     exitCode: number | null;
@@ -29,5 +38,7 @@ export declare function createSpinner(): SpinnerState;
  */
 export declare function startSpinner(label: string, opts?: {
     color?: string;
+    hint?: string;
+    startTime?: number;
 }): SpinnerState;
 export declare function stopSpinner(state: SpinnerState): void;

package/dist/utils/tool-display.js

@@ -37,24 +37,104 @@ export function selectToolDisplayMode(width) {
         return "compact";
     return "summary";
 }
+// ── Kind icons ──────────────────────────────────────────────────
+const KIND_ICONS = {
+    read: "◆",
+    edit: "✎",
+    delete: "✕",
+    move: "↗",
+    search: "⌕",
+    execute: "▶",
+    think: "◇",
+    fetch: "↓",
+    switch_mode: "⇄",
+};
+function kindIcon(kind) {
+    return kind ? (KIND_ICONS[kind] ?? "▶") : "▶";
+}
 // ── Tool call rendering ──────────────────────────────────────────
 export function renderToolCall(tool, width) {
     const mode = selectToolDisplayMode(width);
+    const icon = kindIcon(tool.kind);
     if (mode === "summary") {
-        const text = truncateVisible(`▶ ${tool.title}`, width);
+        const text = truncateVisible(`${icon} ${tool.title}`, width);
         return [`${p.warning}${text}${p.reset}`];
     }
     const lines = [];
-    lines.push(`${p.warning}${p.bold}▶ ${tool.title}${p.reset}`);
-    if (tool.command && mode === "full") {
-        const maxCmdW = Math.max(1, width - 4);
-        const cmd = tool.command.length > maxCmdW
-            ? tool.command.slice(0, maxCmdW - 1) + "…"
-            : tool.command;
-        lines.push(`  ${p.dim}$ ${cmd}${p.reset}`);
+    // Build a compact detail string to append after the title
+    let detail = "";
+    if (mode === "full") {
+        if (tool.command) {
+            detail = `$ ${tool.command}`;
+        }
+        else if (tool.locations && tool.locations.length > 0) {
+            const loc = tool.locations[0];
+            const lineInfo = loc.line ? `:${loc.line}` : "";
+            detail = `${loc.path}${lineInfo}`;
+        }
+        else if (tool.rawInput) {
+            const raw = tool.rawInput;
+            if (raw && typeof raw === "object") {
+                if (typeof raw.command === "string") {
+                    detail = `$ ${raw.command}`;
+                }
+                else if (typeof raw.operation === "string") {
+                    detail = raw.operation;
+                    if (raw.ids && Array.isArray(raw.ids)) {
+                        detail += ` #${raw.ids.join(",")}`;
+                    }
+                    if (typeof raw.query === "string") {
+                        detail += ` "${raw.query}"`;
+                    }
+                }
+                else {
+                    detail = formatRawInput(tool.rawInput, width - tool.title.length - 6);
+                }
+            }
+        }
+    }
+    // Render as single line: ► title: detail
+    const maxDetailW = Math.max(1, width - tool.title.length - 6);
+    if (detail) {
+        if (detail.length > maxDetailW)
+            detail = detail.slice(0, maxDetailW - 1) + "…";
+        lines.push(`${p.warning}${p.bold}${icon} ${tool.title}${p.reset}${p.dim}: ${detail}${p.reset}`);
+    }
+    else {
+        lines.push(`${p.warning}${p.bold}${icon} ${tool.title}${p.reset}`);
+    }
+    // Show additional file locations on separate lines (if more than one)
+    if (mode === "full" && tool.locations && tool.locations.length > 1) {
+        for (const loc of tool.locations.slice(1)) {
+            const lineInfo = loc.line ? `:${loc.line}` : "";
+            lines.push(`  ${p.dim}${loc.path}${lineInfo}${p.reset}`);
+        }
     }
     return lines;
 }
+/**
+ * Format raw input parameters into a compact single-line summary.
+ */
+function formatRawInput(raw, maxWidth) {
+    if (raw == null)
+        return "";
+    if (typeof raw === "string") {
+        return raw.length > maxWidth ? raw.slice(0, maxWidth - 1) + "…" : raw;
+    }
+    if (typeof raw !== "object")
+        return String(raw);
+    // Show key=value pairs for objects
+    const obj = raw;
+    const parts = [];
+    for (const [key, val] of Object.entries(obj)) {
+        if (val == null)
+            continue;
+        const valStr = typeof val === "string" ? val : JSON.stringify(val);
+        parts.push(`${key}=${valStr}`);
+    }
+    const joined = parts.join("  ");
+    return joined.length > maxWidth ? joined.slice(0, maxWidth - 1) + "…" : joined;
+}
 // ── Tool result rendering ────────────────────────────────────────
 export function renderToolResult(result, width) {
     const mode = selectToolDisplayMode(width);
@@ -113,12 +193,15 @@ export function createSpinner() {
  */
 export function startSpinner(label, opts) {
     const state = createSpinner();
+    if (opts?.startTime)
+        state.startTime = opts.startTime;
     const color = opts?.color ?? p.accent;
+    const hint = opts?.hint ? ` ${p.dim}${opts.hint}${p.reset}` : "";
     state.interval = setInterval(() => {
         const frame = SPINNER_FRAMES[state.frame % SPINNER_FRAMES.length];
         const elapsed = formatElapsed(Date.now() - state.startTime);
         const timer = elapsed ? ` ${p.dim}${elapsed}${p.reset}` : "";
-        process.stdout.write(`\r  ${color}${frame} ${label}...${p.reset}${timer}\x1b[K`);
+        process.stdout.write(`\r  ${color}${frame} ${label}...${p.reset}${timer}${hint}\x1b[K`);
         state.frame++;
     }, 80);
     return state;