agent-sh 0.1.0 → 0.3.0

package/dist/input-handler.js

@@ -1,29 +1,119 @@
+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";
+const HISTORY_FILE = path.join(CONFIG_DIR, "history");
 export class InputHandler {
     ctx;
     lineBuffer = "";
     agentInputMode = false;
-    agentInputBuffer = "";
+    editor = new LineEditor();
     autocompleteActive = false;
     autocompleteIndex = 0;
     autocompleteItems = [];
     autocompleteLines = 0;
+    history = [];
+    historyIndex = -1; // -1 = not browsing history
+    savedBuffer = ""; // buffer saved when entering history
+    promptWrappedLines = 0; // extra lines from terminal wrapping
+    escapeTimer = null;
     bus;
     onShowAgentInfo;
     constructor(opts) {
         this.ctx = opts.ctx;
         this.bus = opts.bus;
         this.onShowAgentInfo = opts.onShowAgentInfo;
+        this.loadHistory();
+        // Re-render prompt when config changes (e.g. thinking level cycled)
+        this.bus.on("config:changed", () => {
+            if (this.agentInputMode)
+                this.writeAgentPromptLine();
+        });
+    }
+    loadHistory() {
+        try {
+            const data = fs.readFileSync(HISTORY_FILE, "utf-8");
+            this.history = data.split("\n").filter(Boolean);
+        }
+        catch {
+            // No history file yet
+        }
     }
-    /** Write the agent prompt line (clear + info prefix + ❯ + buffer text). */
+    saveHistory() {
+        try {
+            const { historySize } = getSettings();
+            fs.mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
+            const lines = this.history.slice(-historySize);
+            fs.writeFileSync(HISTORY_FILE, lines.join("\n") + "\n");
+        }
+        catch {
+            // Non-critical — ignore write failures
+        }
+    }
+    /** Write the agent prompt line with cursor at the correct position. */
     writeAgentPromptLine(showBuffer = true) {
+        const termW = process.stdout.columns || 80;
+        // Move cursor to the start of the prompt area (first line of wrapped content)
+        if (this.promptWrappedLines > 0) {
+            process.stdout.write(`\x1b[${this.promptWrappedLines}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 infoPrefix = agentInfo.info ? `${agentInfo.info} ` : "";
-        process.stdout.write("\r\x1b[2K" +
-            infoPrefix +
-            p.warning + p.bold + "❯ " + p.reset +
-            (showBuffer ? p.accent + this.agentInputBuffer + p.reset : ""));
+        const promptPrefix = infoPrefix + p.warning + p.bold + "❯ " + p.reset;
+        const promptVisLen = visibleLen(infoPrefix) + 2; // "❯ "
+        if (!showBuffer || !this.editor.buffer.includes("\n")) {
+            // Single-line: simple rendering
+            const bufferText = showBuffer ? p.accent + this.editor.buffer + p.reset : "";
+            process.stdout.write(promptPrefix + bufferText);
+            const bufferVisLen = showBuffer ? this.editor.buffer.length : 0;
+            const totalVisLen = promptVisLen + bufferVisLen;
+            this.promptWrappedLines = totalVisLen > 0 ? Math.floor((totalVisLen - 1) / termW) : 0;
+            // Position cursor within the buffer
+            if (showBuffer && this.editor.cursor < this.editor.buffer.length) {
+                const charsAfterCursor = this.editor.buffer.length - this.editor.cursor;
+                process.stdout.write(`\x1b[${charsAfterCursor}D`);
+            }
+        }
+        else {
+            // Multi-line: render each line with continuation indent
+            const lines = this.editor.buffer.split("\n");
+            const indent = " ".repeat(promptVisLen);
+            let totalTermLines = 0;
+            for (let li = 0; li < lines.length; li++) {
+                const prefix = li === 0 ? promptPrefix : indent;
+                const prefixVisLen = li === 0 ? promptVisLen : promptVisLen;
+                const lineText = lines[li];
+                process.stdout.write(prefix + p.accent + lineText + p.reset);
+                if (li < lines.length - 1)
+                    process.stdout.write("\n");
+                // Count terminal lines this logical line occupies
+                const lineVisLen = prefixVisLen + lineText.length;
+                totalTermLines += lineVisLen > 0 ? Math.ceil(lineVisLen / termW) : 1;
+            }
+            this.promptWrappedLines = totalTermLines - 1;
+            // Position cursor: find which line and column the cursor is on
+            let charsRemaining = this.editor.cursor;
+            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;
+            }
+            // Move from end position to cursor position
+            const linesFromEnd = lines.length - 1 - cursorLine;
+            if (linesFromEnd > 0) {
+                process.stdout.write(`\x1b[${linesFromEnd}A`);
+            }
+            const cursorCol = (cursorLine === 0 ? promptVisLen : promptVisLen) + charsRemaining;
+            process.stdout.write(`\r\x1b[${cursorCol}C`);
+        }
     }
     handleInput(data) {
         // If agent is running (processing a query), only Ctrl-C and control keys
@@ -36,10 +126,15 @@ export class InputHandler {
             }
             return;
         }
-        // Forward control chars that normal shell mode doesn't handle
+        // Intercept control chars for TUI (Ctrl+T, Ctrl+O) — don't pass to PTY
         if (data.length === 1 && data.charCodeAt(0) < 32 && !this.agentInputMode) {
             const code = data.charCodeAt(0);
-            // Don't intercept keys that shell mode handles: CR, Ctrl-C, Ctrl-D, Tab
+            // 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 });
             }
@@ -89,16 +184,29 @@ export class InputHandler {
     }
     enterAgentInputMode() {
         this.agentInputMode = true;
-        this.agentInputBuffer = "";
+        this.editor.clear();
+        // Enable kitty keyboard protocol (progressive enhancement flag 1)
+        // so Shift+Enter sends \x1b[13;2u instead of plain \r
+        process.stdout.write("\x1b[>1u");
         this.writeAgentPromptLine(false);
     }
     exitAgentInputMode() {
         this.dismissAutocomplete();
         this.agentInputMode = false;
-        this.agentInputBuffer = "";
-        process.stdout.write("\r\x1b[2K");
+        this.editor.clear();
+        // Disable kitty keyboard protocol
+        process.stdout.write("\x1b[<u");
+        this.clearPromptArea();
         this.printPrompt();
     }
+    /** Move to the start of the prompt area and clear everything below. */
+    clearPromptArea() {
+        if (this.promptWrappedLines > 0) {
+            process.stdout.write(`\x1b[${this.promptWrappedLines}A`);
+        }
+        process.stdout.write("\r\x1b[J");
+        this.promptWrappedLines = 0;
+    }
     printPrompt() {
         this.ctx.redrawPrompt();
     }
@@ -109,7 +217,7 @@ export class InputHandler {
     }
     updateAutocomplete() {
         const { items } = this.bus.emitPipe("autocomplete:request", {
-            buffer: this.agentInputBuffer,
+            buffer: this.editor.buffer,
             items: [],
         });
         if (items.length > 0) {
@@ -146,36 +254,27 @@ export class InputHandler {
         }
         const agentInfo = this.onShowAgentInfo();
         const infoLength = visibleLen(agentInfo.info);
-        const col = infoLength + 2 + this.agentInputBuffer.length;
+        const col = infoLength + 2 + this.editor.cursor;
         process.stdout.write(`\r\x1b[${col}C`);
     }
-    clearAutocompleteLines() {
-        if (this.autocompleteLines <= 0)
-            return;
-        process.stdout.write("\x1b7"); // save cursor
-        for (let i = 0; i < this.autocompleteLines; i++) {
-            process.stdout.write("\n\x1b[2K"); // move down, clear line
-        }
-        process.stdout.write("\x1b8"); // restore cursor
-        this.autocompleteLines = 0;
-    }
     applyAutocomplete() {
         if (!this.autocompleteActive || this.autocompleteItems.length === 0)
             return;
         const selected = this.autocompleteItems[this.autocompleteIndex];
         if (!selected)
             return;
-        const atPos = this.agentInputBuffer.lastIndexOf("@");
+        const atPos = this.editor.buffer.lastIndexOf("@");
         const isFileAc = atPos >= 0 &&
-            (atPos === 0 || this.agentInputBuffer[atPos - 1] === " ") &&
-            !this.agentInputBuffer.slice(atPos + 1).includes(" ");
+            (atPos === 0 || this.editor.buffer[atPos - 1] === " ") &&
+            !this.editor.buffer.slice(atPos + 1).includes(" ");
         if (isFileAc) {
-            this.agentInputBuffer =
-                this.agentInputBuffer.slice(0, atPos) + "@" + selected.name;
+            this.editor.buffer =
+                this.editor.buffer.slice(0, atPos) + "@" + selected.name;
         }
         else {
-            this.agentInputBuffer = selected.name;
+            this.editor.buffer = selected.name;
         }
+        this.editor.cursor = this.editor.buffer.length;
         this.clearAutocompleteLines();
         this.autocompleteActive = false;
         this.autocompleteItems = [];
@@ -190,112 +289,145 @@ export class InputHandler {
         this.autocompleteItems = [];
         this.autocompleteIndex = 0;
     }
+    clearAutocompleteLines() {
+        if (this.autocompleteLines <= 0)
+            return;
+        process.stdout.write("\x1b7"); // save cursor
+        for (let i = 0; i < this.autocompleteLines; i++) {
+            process.stdout.write("\n\x1b[2K"); // move down, clear line
+        }
+        process.stdout.write("\x1b8"); // restore cursor
+        this.autocompleteLines = 0;
+    }
     handleAgentInput(data) {
-        for (let i = 0; i < data.length; i++) {
-            const ch = data[i];
-            // Detect arrow key sequences: \x1b[A (up), \x1b[B (down)
-            if (ch === "\x1b" && data[i + 1] === "[") {
-                const arrow = data[i + 2];
-                if (arrow === "A" && this.autocompleteActive) {
-                    // Arrow up
-                    this.autocompleteIndex =
-                        this.autocompleteIndex === 0
-                            ? this.autocompleteItems.length - 1
-                            : this.autocompleteIndex - 1;
-                    this.clearAutocompleteLines();
-                    this.writeAgentPromptLine();
-                    this.renderAutocomplete();
-                    i += 2;
-                    continue;
-                }
-                else if (arrow === "B" && this.autocompleteActive) {
-                    this.autocompleteIndex =
-                        this.autocompleteIndex === this.autocompleteItems.length - 1
-                            ? 0
-                            : this.autocompleteIndex + 1;
+        // 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;
+                const flushed = this.editor.flushPendingEscape();
+                if (flushed.length > 0)
+                    this.processAgentActions(flushed);
+            }, 50);
+        }
+        this.processAgentActions(actions);
+    }
+    processAgentActions(actions) {
+        for (const act of actions) {
+            switch (act.action) {
+                case "changed":
+                    this.historyIndex = -1;
+                    this.autocompleteIndex = 0;
+                    this.renderAgentInput();
+                    break;
+                case "submit": {
+                    if (this.autocompleteActive) {
+                        this.applyAutocomplete();
+                    }
+                    const query = act.buffer.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();
+                        }
+                    }
+                    this.historyIndex = -1;
+                    this.savedBuffer = "";
                     this.clearAutocompleteLines();
-                    this.writeAgentPromptLine();
-                    this.renderAutocomplete();
-                    i += 2;
-                    continue;
-                }
-                else if (!this.autocompleteActive) {
-                    // Escape without arrow: cancel agent input mode
+                    this.clearPromptArea();
+                    process.stdout.write("\x1b[<u"); // disable kitty keyboard protocol
+                    this.agentInputMode = false;
+                    this.editor.clear();
                     this.dismissAutocomplete();
-                    this.exitAgentInputMode();
+                    if (query && query.startsWith("/")) {
+                        const spaceIdx = query.indexOf(" ");
+                        const name = spaceIdx === -1 ? query : query.slice(0, spaceIdx);
+                        const args = spaceIdx === -1 ? "" : query.slice(spaceIdx + 1).trim();
+                        this.bus.emit("command:execute", { name, args });
+                        this.ctx.redrawPrompt();
+                    }
+                    else if (query) {
+                        this.bus.emit("agent:submit", { query });
+                    }
+                    else {
+                        this.exitAgentInputMode();
+                    }
                     return;
                 }
-                // Other escape sequences (e.g. left/right arrow) — ignore for now
-                i += 2;
-                continue;
-            }
-            if (ch === "\x1b") {
-                // Bare escape (no bracket follows)
-                if (this.autocompleteActive) {
-                    this.dismissAutocomplete();
-                    this.writeAgentPromptLine();
-                }
-                else {
-                    this.dismissAutocomplete();
-                    this.exitAgentInputMode();
-                }
-                return;
-            }
-            if (ch === "\t") {
-                if (this.autocompleteActive) {
-                    this.applyAutocomplete();
-                }
-                continue;
-            }
-            if (ch === "\r") {
-                if (this.autocompleteActive) {
-                    this.applyAutocomplete();
-                }
-                const query = this.agentInputBuffer.trim();
-                this.clearAutocompleteLines();
-                process.stdout.write("\r\x1b[2K");
-                this.agentInputMode = false;
-                this.agentInputBuffer = "";
-                this.dismissAutocomplete();
-                if (query && query.startsWith("/")) {
-                    const spaceIdx = query.indexOf(" ");
-                    const name = spaceIdx === -1 ? query : query.slice(0, spaceIdx);
-                    const args = spaceIdx === -1 ? "" : query.slice(spaceIdx + 1).trim();
-                    this.bus.emit("command:execute", { name, args });
-                    this.ctx.redrawPrompt();
-                }
-                else if (query) {
-                    this.bus.emit("agent:submit", { query });
-                }
-                else {
-                    this.exitAgentInputMode();
-                }
-                return;
-            }
-            else if (ch === "\x03") {
-                // Ctrl-C: cancel
-                this.dismissAutocomplete();
-                this.exitAgentInputMode();
-                return;
-            }
-            else if (ch === "\x7f" || ch === "\b") {
-                // Backspace
-                if (this.agentInputBuffer.length > 0) {
-                    this.agentInputBuffer = this.agentInputBuffer.slice(0, -1);
-                    this.autocompleteIndex = 0;
-                    this.renderAgentInput();
-                }
-                else {
+                case "cancel":
+                    if (this.autocompleteActive) {
+                        this.dismissAutocomplete();
+                        this.writeAgentPromptLine();
+                    }
+                    else {
+                        this.exitAgentInputMode();
+                    }
+                    return;
+                case "delete-empty":
                     this.dismissAutocomplete();
                     this.exitAgentInputMode();
                     return;
-                }
-            }
-            else if (ch.charCodeAt(0) >= 32) {
-                // Printable character
-                this.agentInputBuffer += ch;
-                this.autocompleteIndex = 0;
-                this.renderAgentInput();
+                case "tab":
+                    if (this.autocompleteActive) {
+                        this.applyAutocomplete();
+                    }
+                    break;
+                case "shift+tab":
+                    this.bus.emit("config:cycle", {});
+                    break;
+                case "arrow-up":
+                    if (this.autocompleteActive) {
+                        this.autocompleteIndex =
+                            this.autocompleteIndex === 0
+                                ? this.autocompleteItems.length - 1
+                                : this.autocompleteIndex - 1;
+                        this.clearAutocompleteLines();
+                        this.writeAgentPromptLine();
+                        this.renderAutocomplete();
+                    }
+                    else if (this.history.length > 0) {
+                        if (this.historyIndex === -1) {
+                            this.savedBuffer = this.editor.buffer;
+                            this.historyIndex = this.history.length - 1;
+                        }
+                        else if (this.historyIndex > 0) {
+                            this.historyIndex--;
+                        }
+                        this.editor.buffer = this.history[this.historyIndex];
+                        this.editor.cursor = this.editor.buffer.length;
+                        this.renderAgentInput();
+                    }
+                    break;
+                case "arrow-down":
+                    if (this.autocompleteActive) {
+                        this.autocompleteIndex =
+                            this.autocompleteIndex === this.autocompleteItems.length - 1
+                                ? 0
+                                : this.autocompleteIndex + 1;
+                        this.clearAutocompleteLines();
+                        this.writeAgentPromptLine();
+                        this.renderAutocomplete();
+                    }
+                    else if (this.historyIndex !== -1) {
+                        if (this.historyIndex < this.history.length - 1) {
+                            this.historyIndex++;
+                            this.editor.buffer = this.history[this.historyIndex];
+                        }
+                        else {
+                            this.historyIndex = -1;
+                            this.editor.buffer = this.savedBuffer;
+                        }
+                        this.editor.cursor = this.editor.buffer.length;
+                        this.renderAgentInput();
+                    }
+                    break;
             }
         }
     }

package/dist/mcp-server.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Minimal MCP server exposing a `user_shell` tool.
+ *
+ * Spawned by the ACP agent (pi-acp, claude-agent-acp, etc.) as an MCP
+ * stdio server. When the LLM calls `user_shell`, this process connects
+ * to agent-sh's Unix socket to execute the command in the user's live
+ * PTY shell.
+ *
+ * Protocol: MCP over stdio (newline-delimited JSON-RPC 2.0).
+ * No SDK dependency — the protocol surface is tiny.
+ */
+export {};