agent-sh 0.12.2 → 0.12.4

package/dist/shell/input-handler.js

@@ -1,41 +1,38 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { visibleLen } from "../utils/ansi.js";
-import { palette as p } from "../utils/palette.js";
 import { LineEditor } from "../utils/line-editor.js";
 import { CONFIG_DIR, getSettings } from "../settings.js";
+import { TuiInputView } from "./tui-input-view.js";
 const HISTORY_FILE = path.join(CONFIG_DIR, "input-history");
+/** Line editor + shell-passthrough buffer. Delegates rendering to TuiInputView. */
 export class InputHandler {
     ctx;
     lineBuffer = "";
     activeMode = null;
-    pendingReturnMode = null; // mode id to return to after processing
-    modes = new Map(); // keyed by trigger char
-    modesById = new Map(); // keyed by id
+    pendingReturnMode = null;
+    modes = new Map();
+    modesById = new Map();
     editor = new LineEditor();
     autocompleteActive = false;
     autocompleteIndex = 0;
     autocompleteItems = [];
-    autocompleteLines = 0;
     history = [];
-    historyIndex = -1; // -1 = not browsing history
-    savedBuffer = ""; // buffer saved when entering history
-    cursorRowsBelow = 0; // rows from prompt top to cursor row
-    cursorTermCol = 1; // 1-indexed terminal column of cursor
+    historyIndex = -1;
+    savedBuffer = "";
     escapeTimer = null;
     bus;
     onShowAgentInfo;
+    view;
     constructor(opts) {
         this.ctx = opts.ctx;
         this.bus = opts.bus;
         this.onShowAgentInfo = opts.onShowAgentInfo;
+        this.view = opts.view ?? new TuiInputView();
         this.loadHistory();
-        // Re-render prompt when config changes (e.g. thinking level cycled)
         this.bus.on("config:changed", () => {
             if (this.activeMode)
-                this.writeModePromptLine();
+                this.drawPrompt();
         });
-        // Listen for mode registrations from extensions
         this.bus.on("input-mode:register", (config) => {
             this.registerMode(config);
         });
@@ -56,7 +53,6 @@ export class InputHandler {
             this.history = data.split("\n").filter(Boolean);
         }
         catch {
-            // No history file yet
         }
     }
     saveHistory() {
@@ -67,108 +63,22 @@ export class InputHandler {
             fs.writeFileSync(HISTORY_FILE, lines.join("\n") + "\n");
         }
         catch {
-            // Non-critical — ignore write failures
         }
     }
-    /** Write the mode prompt line with cursor at the correct position. */
-    writeModePromptLine(showBuffer = true) {
-        const termW = process.stdout.columns || 80;
-        // Move cursor to the start of the prompt area.
-        // We know exactly how many rows below the top the cursor currently sits.
-        if (this.cursorRowsBelow > 0) {
-            process.stdout.write(`\x1b[${this.cursorRowsBelow}A`);
-        }
-        // Clear from here to end of screen — removes current + all wrapped lines below
-        process.stdout.write("\r\x1b[J");
-        const agentInfo = this.onShowAgentInfo();
-        const indicator = this.activeMode?.indicator ?? "●";
-        const infoPrefix = agentInfo.info
-            ? `${agentInfo.info} ${p.success}${indicator}${p.reset} `
-            : `${p.success}${indicator}${p.reset} `;
-        const icon = this.activeMode?.promptIcon ?? "❯";
-        const promptPrefix = infoPrefix + p.warning + p.bold + icon + " " + p.reset;
-        const promptVisLen = visibleLen(infoPrefix) + visibleLen(icon) + 1; // icon + space
-        const display = showBuffer ? this.editor.displayText : "";
-        const dCursor = showBuffer ? this.editor.displayCursor : 0;
-        if (!showBuffer) {
-            // No buffer — just write the prompt prefix, cursor stays at end
-            process.stdout.write(promptPrefix);
-            const N = promptVisLen;
-            this.cursorRowsBelow = N > 0 ? Math.ceil(N / termW) - 1 : 0;
-            this.cursorTermCol = N === 0 ? 1 : (N % termW === 0 ? termW : (N % termW) + 1);
-        }
-        else if (!display.includes("\n")) {
-            // Single-line: write up to cursor, save, write rest, restore.
-            // The terminal handles all wrapping — no manual row/col math needed.
-            const before = display.slice(0, dCursor);
-            const after = display.slice(dCursor);
-            process.stdout.write(promptPrefix + p.accent + before + p.reset +
-                "\x1b7" + // DECSC — save cursor position
-                p.accent + after + p.reset +
-                "\x1b8" // DECRC — restore cursor position
-            );
-            // cursorRowsBelow is distance from cursor (restored by DECRC, sitting at
-            // the cursor col) back up to the prompt's top row. Next redraw uses it
-            // with \x1b[${n}A then \x1b[J — moving past the top scrolls the screen.
-            const cursorVisCol = promptVisLen + visibleLen(before);
-            this.cursorRowsBelow = cursorVisCol > 0 ? Math.ceil(cursorVisCol / termW) - 1 : 0;
-            this.cursorTermCol = cursorVisCol === 0 ? 1 : (cursorVisCol % termW === 0 ? termW : (cursorVisCol % termW) + 1);
-        }
-        else {
-            // Multi-line: render each line with continuation indent.
-            // Same save/restore strategy — cursor position is never computed.
-            const lines = display.split("\n");
-            const indent = " ".repeat(promptVisLen);
-            // Locate cursor: which logical line and offset within it.
-            let charsRemaining = dCursor;
-            let cursorLine = 0;
-            for (let li = 0; li < lines.length; li++) {
-                if (charsRemaining <= lines[li].length) {
-                    cursorLine = li;
-                    break;
-                }
-                charsRemaining -= lines[li].length + 1; // +1 for \n
-                cursorLine = li + 1;
-            }
-            let output = "";
-            let cursorRowFromTop = 0;
-            let rowsSoFar = 0;
-            for (let li = 0; li < lines.length; li++) {
-                const prefix = li === 0 ? promptPrefix : indent;
-                const lineText = lines[li];
-                const lineVisLen = promptVisLen + visibleLen(lineText);
-                const lineTermRows = lineVisLen > 0 ? Math.ceil(lineVisLen / termW) : 1;
-                if (li === cursorLine) {
-                    // Split this line at the cursor.
-                    const before = lineText.slice(0, charsRemaining);
-                    const after = lineText.slice(charsRemaining);
-                    output += prefix + p.accent + before + p.reset;
-                    output += "\x1b7"; // DECSC — save cursor position
-                    output += p.accent + after + p.reset;
-                    const beforeVisCol = promptVisLen + visibleLen(before);
-                    cursorRowFromTop = rowsSoFar + (beforeVisCol > 0 ? Math.ceil(beforeVisCol / termW) - 1 : 0);
-                    this.cursorTermCol = beforeVisCol === 0 ? 1 : (beforeVisCol % termW === 0 ? termW : (beforeVisCol % termW) + 1);
-                }
-                else {
-                    output += prefix + p.accent + lineText + p.reset;
-                }
-                if (li < lines.length - 1)
-                    output += "\n";
-                rowsSoFar += lineTermRows;
-            }
-            process.stdout.write(output + "\x1b8"); // DECRC — restore cursor position
-            // Distance from cursor (where DECRC lands) back to the top row. Next
-            // redraw moves up by this and clears to end-of-screen — \x1b[J handles
-            // everything below, including rows after the cursor's logical line.
-            this.cursorRowsBelow = cursorRowFromTop;
-        }
+    drawPrompt(showBuffer = true) {
+        this.view.drawPrompt({
+            showBuffer,
+            displayText: this.editor.displayText,
+            displayCursor: this.editor.displayCursor,
+            indicator: this.activeMode?.indicator ?? "●",
+            promptIcon: this.activeMode?.promptIcon ?? "❯",
+            agentInfo: this.onShowAgentInfo(),
+        });
     }
     handleInput(data) {
-        // Allow extensions to capture raw input (e.g. overlay prompt during vim)
         const intercepted = this.bus.emitPipe("input:intercept", { data, consumed: false });
         if (intercepted.consumed)
             return;
-        // If agent is running (processing a query), only Ctrl-C and control keys
         if (this.ctx.isAgentActive()) {
             if (data === "\x03") {
                 this.bus.emit("agent:cancel-request", {});
@@ -178,20 +88,16 @@ export class InputHandler {
             }
             return;
         }
-        // Intercept control chars for TUI (Ctrl+T, Ctrl+O) — don't pass to PTY
         if (data.length === 1 && data.charCodeAt(0) < 32 && !this.activeMode) {
             const code = data.charCodeAt(0);
-            // Keys consumed by TUI extensions
             if (code === 0x14 || code === 0x0f) { // Ctrl+T, Ctrl+O
                 this.bus.emit("input:keypress", { key: data });
                 return;
             }
-            // Forward other control chars that shell mode doesn't handle
             if (code !== 0x0d && code !== 0x03 && code !== 0x04 && code !== 0x09) {
                 this.bus.emit("input:keypress", { key: data });
             }
         }
-        // If in an input mode (typing a query)
         if (this.activeMode) {
             this.handleModeInput(data);
             return;
@@ -199,7 +105,6 @@ export class InputHandler {
         for (let i = 0; i < data.length; i++) {
             const ch = data[i];
             if (ch === "\r") {
-                // Record the command — output will be captured until next prompt marker
                 if (this.lineBuffer.trim()) {
                     this.ctx.onCommandEntered(this.lineBuffer.trim(), this.ctx.getCwd());
                 }
@@ -210,29 +115,22 @@ export class InputHandler {
                 this.lineBuffer = this.lineBuffer.slice(0, -1);
                 this.ctx.writeToPty(ch);
             }
-            else if (ch === "\x03") {
-                this.lineBuffer = "";
-                this.ctx.writeToPty(ch);
-            }
-            else if (ch === "\x04") {
+            else if (ch === "\x03" || ch === "\x04") {
                 this.lineBuffer = "";
                 this.ctx.writeToPty(ch);
             }
             else if (ch === "\x0b" || ch === "\x15") {
-                // Ctrl-K / Ctrl-U kill the line in the shell; mirror that so the
-                // mode-trigger check sees an empty buffer. Not cursor-accurate.
+                // Ctrl-K / Ctrl-U: shell kills the line; mirror so lineBuffer stays in sync.
                 this.lineBuffer = "";
                 this.ctx.writeToPty(ch);
             }
             else if (ch === "\x1b") {
-                // Escape sequence — forward the entire sequence to the PTY but
-                // don't let it corrupt lineBuffer.  Skip CSI (ESC [ ... final)
-                // and SS3 (ESC O <char>) sequences; anything else: just ESC.
+                // Forward whole escape sequence as a unit — otherwise payload bytes
+                // (e.g. OSC color-query response) can leak into lineBuffer.
                 let seq = ch;
                 if (i + 1 < data.length) {
                     const next = data[i + 1];
                     if (next === "[") {
-                        // CSI: ESC [ (params) (intermediates) final_byte
                         seq += next;
                         i++;
                         while (i + 1 < data.length && data[i + 1].charCodeAt(0) < 0x40) {
@@ -242,10 +140,9 @@ export class InputHandler {
                         if (i + 1 < data.length) {
                             i++;
                             seq += data[i];
-                        } // final byte
+                        }
                     }
                     else if (next === "O") {
-                        // SS3: ESC O <char>
                         seq += next;
                         i++;
                         if (i + 1 < data.length) {
@@ -254,12 +151,7 @@ export class InputHandler {
                         }
                     }
                     else if (next === "]" || next === "P" || next === "_" || next === "^") {
-                        // String sequences terminated by BEL or ST (ESC \):
-                        //   OSC (ESC ]) — OSC 10/11 color-query responses
-                        //   DCS (ESC P) — tmux XTVERSION query response (iTerm2 etc.)
-                        //   APC (ESC _), PM (ESC ^) — rarer, same termination
-                        // Forward as a unit so the payload doesn't leak into lineBuffer
-                        // and onto the bash command line after a foreground app exits.
+                        // OSC/DCS/APC/PM — terminated by BEL or ST (ESC \).
                         let j = i + 2;
                         let termEnd = -1;
                         while (j < data.length) {
@@ -284,7 +176,6 @@ export class InputHandler {
                         }
                     }
                     else {
-                        // ESC + single char (alt-key, etc.)
                         seq += next;
                         i++;
                     }
@@ -295,12 +186,10 @@ export class InputHandler {
                 this.ctx.writeToPty(ch);
             }
             else {
-                // Check if trigger char at start of empty line → enter that mode
-                // But not if a foreground process (ssh, vim, etc.) is running
                 const mode = this.modes.get(ch);
                 if (this.lineBuffer === "" && mode && !this.ctx.isForegroundBusy()) {
                     this.enterMode(mode);
-                    return; // don't process remaining chars
+                    return;
                 }
                 if (!this.ctx.isForegroundBusy())
                     this.lineBuffer += ch;
@@ -311,38 +200,23 @@ export class InputHandler {
     enterMode(mode) {
         this.activeMode = mode;
         this.editor.clear();
-        // Enable kitty keyboard protocol (progressive enhancement flag 1)
-        // so Shift+Enter sends \x1b[13;2u instead of plain \r.
-        // Enable bracket paste mode so pasted text doesn't trigger submit.
-        process.stdout.write("\x1b[>1u\x1b[?2004h");
-        this.writeModePromptLine(false);
+        this.view.enableModeKeys();
+        this.drawPrompt(false);
     }
     exitMode() {
         this.dismissAutocomplete();
         this.activeMode = null;
         this.editor.clear();
-        // Disable kitty keyboard protocol and bracket paste mode
-        process.stdout.write("\x1b[<u\x1b[?2004l");
-        this.clearPromptArea();
-        this.cursorRowsBelow = 0;
-        this.cursorTermCol = 1;
+        this.view.disableModeKeys();
+        this.view.clearPromptArea();
+        this.view.resetCursor();
         this.printPrompt();
     }
-    /** Move to the start of the prompt area and clear everything below. */
-    clearPromptArea() {
-        if (this.cursorRowsBelow > 0) {
-            process.stdout.write(`\x1b[${this.cursorRowsBelow}A`);
-        }
-        process.stdout.write("\r\x1b[J");
-        this.cursorRowsBelow = 0;
-    }
     printPrompt() {
         this.ctx.redrawPrompt();
     }
-    /**
-     * Called when agent processing completes. Returns true if the input
-     * handler re-entered a mode (so caller should skip shell prompt).
-     */
+    /** Called when agent processing completes. Returns true if the input
+     *  handler re-entered a mode (so caller should skip shell prompt). */
     handleProcessingDone() {
         if (this.pendingReturnMode) {
             const mode = this.modesById.get(this.pendingReturnMode);
@@ -355,8 +229,8 @@ export class InputHandler {
         return false;
     }
     renderModeInput() {
-        this.clearAutocompleteLines();
-        this.writeModePromptLine();
+        this.view.clearAutocomplete();
+        this.drawPrompt();
         this.updateAutocomplete();
     }
     updateAutocomplete() {
@@ -381,38 +255,13 @@ export class InputHandler {
             this.autocompleteActive = true;
             if (this.autocompleteIndex >= items.length)
                 this.autocompleteIndex = 0;
-            this.renderAutocomplete();
+            this.view.drawAutocomplete({ items: this.autocompleteItems, selected: this.autocompleteIndex });
         }
         else {
             this.autocompleteActive = false;
             this.autocompleteItems = [];
-            this.autocompleteLines = 0;
         }
     }
-    renderAutocomplete() {
-        if (!this.autocompleteActive || this.autocompleteItems.length === 0)
-            return;
-        const lines = [];
-        for (let i = 0; i < this.autocompleteItems.length; i++) {
-            const item = this.autocompleteItems[i];
-            const selected = i === this.autocompleteIndex;
-            if (selected) {
-                lines.push(`  \x1b[7m ${p.accent}${item.name.padEnd(12)}${p.reset}\x1b[7m ${item.description} ${p.reset}`);
-            }
-            else {
-                lines.push(`   ${p.muted}${item.name.padEnd(12)} ${item.description}${p.reset}`);
-            }
-        }
-        process.stdout.write("\n" + lines.join("\n"));
-        this.autocompleteLines = lines.length;
-        if (this.autocompleteLines > 0) {
-            process.stdout.write(`\x1b[${this.autocompleteLines}A`);
-        }
-        // Restore cursor column — use explicit column set instead of DECRC
-        // because writing \n above may have scrolled the terminal, which
-        // invalidates the absolute position saved by DECSC.
-        process.stdout.write(`\x1b[${this.cursorTermCol}G`);
-    }
     applyAutocomplete() {
         if (!this.autocompleteActive || this.autocompleteItems.length === 0)
             return;
@@ -429,40 +278,26 @@ export class InputHandler {
         else {
             this.editor.setText(selected.name);
         }
-        this.clearAutocompleteLines();
+        this.view.clearAutocomplete();
         this.autocompleteActive = false;
         this.autocompleteItems = [];
         this.autocompleteIndex = 0;
-        this.writeModePromptLine();
+        this.drawPrompt();
         if (isFileAc)
             this.updateAutocomplete();
     }
     dismissAutocomplete() {
-        this.clearAutocompleteLines();
+        this.view.clearAutocomplete();
         this.autocompleteActive = false;
         this.autocompleteItems = [];
         this.autocompleteIndex = 0;
     }
-    clearAutocompleteLines() {
-        if (this.autocompleteLines <= 0)
-            return;
-        // Use CSI B (cursor down, bounded) instead of \n to avoid scroll
-        for (let i = 0; i < this.autocompleteLines; i++) {
-            process.stdout.write("\x1b[B\x1b[2K"); // move down, clear line
-        }
-        // Move back up and restore column with relative movement (scroll-safe)
-        process.stdout.write(`\x1b[${this.autocompleteLines}A\x1b[${this.cursorTermCol}G`);
-        this.autocompleteLines = 0;
-    }
     handleModeInput(data) {
-        // Clear any pending escape timer — new data arrived
         if (this.escapeTimer) {
             clearTimeout(this.escapeTimer);
             this.escapeTimer = null;
         }
         const actions = this.editor.feed(data);
-        // If the editor is waiting for more escape sequence data, set a short
-        // timer — if nothing arrives, treat it as a bare Escape keypress
         if (this.editor.hasPendingEscape()) {
             this.escapeTimer = setTimeout(() => {
                 this.escapeTimer = null;
@@ -477,14 +312,13 @@ export class InputHandler {
         for (const act of actions) {
             switch (act.action) {
                 case "changed": {
-                    // If the buffer is exactly a trigger char for a different mode, switch to it
                     const switchMode = this.modes.get(this.editor.text);
                     if (this.editor.text.length === 1 && switchMode && switchMode !== this.activeMode) {
                         this.dismissAutocomplete();
-                        this.clearPromptArea();
+                        this.view.clearPromptArea();
                         this.activeMode = switchMode;
                         this.editor.clear();
-                        this.writeModePromptLine(false);
+                        this.drawPrompt(false);
                         break;
                     }
                     this.historyIndex = -1;
@@ -496,12 +330,9 @@ export class InputHandler {
                     if (this.autocompleteActive) {
                         this.applyAutocomplete();
                     }
-                    // Use editor.text (not act.buffer) so autocomplete selections
-                    // take effect — act.buffer is a stale snapshot from before
-                    // applyAutocomplete() updated the editor.
+                    // Use editor.text (not act.buffer) so autocomplete selections take effect.
                     const query = this.editor.text.trim();
                     if (query) {
-                        // Add to history (avoid consecutive duplicates)
                         if (this.history.length === 0 || this.history[this.history.length - 1] !== query) {
                             this.history.push(query);
                             this.saveHistory();
@@ -509,14 +340,13 @@ export class InputHandler {
                     }
                     this.historyIndex = -1;
                     this.savedBuffer = "";
-                    this.clearAutocompleteLines();
-                    this.clearPromptArea();
-                    process.stdout.write("\x1b[<u\x1b[?2004l"); // disable kitty + bracket paste
+                    this.view.clearAutocomplete();
+                    this.view.clearPromptArea();
+                    this.view.disableModeKeys();
                     const currentMode = this.activeMode;
                     this.activeMode = null;
                     this.editor.clear();
-                    this.cursorRowsBelow = 0;
-                    this.cursorTermCol = 1;
+                    this.view.resetCursor();
                     this.dismissAutocomplete();
                     if (query && query.startsWith("/")) {
                         const spaceIdx = query.indexOf(" ");
@@ -542,7 +372,7 @@ export class InputHandler {
                 case "cancel":
                     if (this.autocompleteActive) {
                         this.dismissAutocomplete();
-                        this.writeModePromptLine();
+                        this.drawPrompt();
                     }
                     else {
                         this.exitMode();
@@ -563,9 +393,9 @@ export class InputHandler {
                             this.autocompleteIndex === 0
                                 ? this.autocompleteItems.length - 1
                                 : this.autocompleteIndex - 1;
-                        this.clearAutocompleteLines();
-                        this.writeModePromptLine();
-                        this.renderAutocomplete();
+                        this.view.clearAutocomplete();
+                        this.drawPrompt();
+                        this.view.drawAutocomplete({ items: this.autocompleteItems, selected: this.autocompleteIndex });
                     }
                     else if (this.history.length > 0) {
                         if (this.historyIndex === -1) {
@@ -576,8 +406,8 @@ export class InputHandler {
                             this.historyIndex--;
                         }
                         this.editor.setText(this.history[this.historyIndex]);
-                        this.clearAutocompleteLines();
-                        this.writeModePromptLine();
+                        this.view.clearAutocomplete();
+                        this.drawPrompt();
                     }
                     break;
                 case "arrow-down":
@@ -586,9 +416,9 @@ export class InputHandler {
                             this.autocompleteIndex === this.autocompleteItems.length - 1
                                 ? 0
                                 : this.autocompleteIndex + 1;
-                        this.clearAutocompleteLines();
-                        this.writeModePromptLine();
-                        this.renderAutocomplete();
+                        this.view.clearAutocomplete();
+                        this.drawPrompt();
+                        this.view.drawAutocomplete({ items: this.autocompleteItems, selected: this.autocompleteIndex });
                     }
                     else if (this.historyIndex !== -1) {
                         if (this.historyIndex < this.history.length - 1) {
@@ -599,8 +429,8 @@ export class InputHandler {
                             this.historyIndex = -1;
                             this.editor.setText(this.savedBuffer);
                         }
-                        this.clearAutocompleteLines();
-                        this.writeModePromptLine();
+                        this.view.clearAutocomplete();
+                        this.drawPrompt();
                     }
                     break;
             }

package/dist/shell/shell.js

@@ -5,7 +5,7 @@ import * as pty from "node-pty";
 import { InputHandler } from "./input-handler.js";
 import { OutputParser } from "./output-parser.js";
 import { getSettings } from "../settings.js";
-import { RefCounter } from "../utils/output-writer.js";
+import { RefCounter } from "../utils/ref-counter.js";
 export class Shell {
     ptyProcess;
     bus;

package/dist/shell/tui-input-view.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Terminal renderer for the input-mode prompt and autocomplete dropdown.
+ * Owns screen state (cursor row/col, autocomplete line count) and the
+ * ANSI redraw. The controller drives it via a small VM shape.
+ */
+import type { RenderSurface } from "../utils/compositor.js";
+export interface PromptVM {
+    showBuffer: boolean;
+    displayText: string;
+    displayCursor: number;
+    indicator: string;
+    promptIcon: string;
+    agentInfo: {
+        info: string;
+    };
+}
+export interface AutocompleteVM {
+    items: {
+        name: string;
+        description: string;
+    }[];
+    selected: number;
+}
+export declare class TuiInputView {
+    private cursorRowsBelow;
+    private cursorTermCol;
+    private autocompleteLines;
+    private readonly surface;
+    constructor(surface?: RenderSurface);
+    resetCursor(): void;
+    enableModeKeys(): void;
+    disableModeKeys(): void;
+    clearPromptArea(): void;
+    drawPrompt(vm: PromptVM): void;
+    drawAutocomplete(vm: AutocompleteVM): void;
+    clearAutocomplete(): void;
+}