agent-sh 0.1.0

package/dist/input-handler.js

@@ -0,0 +1,302 @@
+import { visibleLen } from "./utils/ansi.js";
+import { palette as p } from "./utils/palette.js";
+export class InputHandler {
+    ctx;
+    lineBuffer = "";
+    agentInputMode = false;
+    agentInputBuffer = "";
+    autocompleteActive = false;
+    autocompleteIndex = 0;
+    autocompleteItems = [];
+    autocompleteLines = 0;
+    bus;
+    onShowAgentInfo;
+    constructor(opts) {
+        this.ctx = opts.ctx;
+        this.bus = opts.bus;
+        this.onShowAgentInfo = opts.onShowAgentInfo;
+    }
+    /** Write the agent prompt line (clear + info prefix + ❯ + buffer text). */
+    writeAgentPromptLine(showBuffer = true) {
+        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 : ""));
+    }
+    handleInput(data) {
+        // 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", {});
+            }
+            else if (data.length === 1 && data.charCodeAt(0) < 32) {
+                this.bus.emit("input:keypress", { key: data });
+            }
+            return;
+        }
+        // Forward control chars that normal shell mode doesn't handle
+        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
+            if (code !== 0x0d && code !== 0x03 && code !== 0x04 && code !== 0x09) {
+                this.bus.emit("input:keypress", { key: data });
+            }
+        }
+        // If in agent input mode (typing a query after ">")
+        if (this.agentInputMode) {
+            this.handleAgentInput(data);
+            return;
+        }
+        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());
+                }
+                this.lineBuffer = "";
+                this.ctx.writeToPty(ch);
+            }
+            else if (ch === "\x7f" || ch === "\b") {
+                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") {
+                this.lineBuffer = "";
+                this.ctx.writeToPty(ch);
+            }
+            else if (ch.charCodeAt(0) < 32 && ch !== "\t") {
+                this.lineBuffer = "";
+                this.ctx.writeToPty(ch);
+            }
+            else {
+                // Check if ">" at start of empty line → enter agent input mode
+                // But not if a foreground process (ssh, vim, etc.) is running
+                if (this.lineBuffer === "" && ch === ">" && !this.ctx.isForegroundBusy()) {
+                    this.enterAgentInputMode();
+                    return; // don't process remaining chars
+                }
+                this.lineBuffer += ch;
+                this.ctx.writeToPty(ch);
+            }
+        }
+    }
+    enterAgentInputMode() {
+        this.agentInputMode = true;
+        this.agentInputBuffer = "";
+        this.writeAgentPromptLine(false);
+    }
+    exitAgentInputMode() {
+        this.dismissAutocomplete();
+        this.agentInputMode = false;
+        this.agentInputBuffer = "";
+        process.stdout.write("\r\x1b[2K");
+        this.printPrompt();
+    }
+    printPrompt() {
+        this.ctx.redrawPrompt();
+    }
+    renderAgentInput() {
+        this.clearAutocompleteLines();
+        this.writeAgentPromptLine();
+        this.updateAutocomplete();
+    }
+    updateAutocomplete() {
+        const { items } = this.bus.emitPipe("autocomplete:request", {
+            buffer: this.agentInputBuffer,
+            items: [],
+        });
+        if (items.length > 0) {
+            this.autocompleteItems = items;
+            this.autocompleteActive = true;
+            if (this.autocompleteIndex >= items.length)
+                this.autocompleteIndex = 0;
+            this.renderAutocomplete();
+        }
+        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`);
+        }
+        const agentInfo = this.onShowAgentInfo();
+        const infoLength = visibleLen(agentInfo.info);
+        const col = infoLength + 2 + this.agentInputBuffer.length;
+        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 isFileAc = atPos >= 0 &&
+            (atPos === 0 || this.agentInputBuffer[atPos - 1] === " ") &&
+            !this.agentInputBuffer.slice(atPos + 1).includes(" ");
+        if (isFileAc) {
+            this.agentInputBuffer =
+                this.agentInputBuffer.slice(0, atPos) + "@" + selected.name;
+        }
+        else {
+            this.agentInputBuffer = selected.name;
+        }
+        this.clearAutocompleteLines();
+        this.autocompleteActive = false;
+        this.autocompleteItems = [];
+        this.autocompleteIndex = 0;
+        this.writeAgentPromptLine();
+        if (isFileAc)
+            this.updateAutocomplete();
+    }
+    dismissAutocomplete() {
+        this.clearAutocompleteLines();
+        this.autocompleteActive = false;
+        this.autocompleteItems = [];
+        this.autocompleteIndex = 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;
+                    this.clearAutocompleteLines();
+                    this.writeAgentPromptLine();
+                    this.renderAutocomplete();
+                    i += 2;
+                    continue;
+                }
+                else if (!this.autocompleteActive) {
+                    // Escape without arrow: cancel agent input mode
+                    this.dismissAutocomplete();
+                    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 {
+                    this.dismissAutocomplete();
+                    this.exitAgentInputMode();
+                    return;
+                }
+            }
+            else if (ch.charCodeAt(0) >= 32) {
+                // Printable character
+                this.agentInputBuffer += ch;
+                this.autocompleteIndex = 0;
+                this.renderAgentInput();
+            }
+        }
+    }
+}

package/dist/output-parser.d.ts

@@ -0,0 +1,55 @@
+import type { EventBus } from "./event-bus.js";
+/**
+ * Parses PTY output to detect command boundaries, track cwd,
+ * and emit shell events. Owns the command lifecycle state.
+ */
+export declare class OutputParser {
+    private bus;
+    private cwd;
+    private currentOutputCapture;
+    private lastCommand;
+    private foregroundBusy;
+    private capturingPrompt;
+    private promptCaptureComplete;
+    private promptBuffer;
+    private lastPrompt;
+    constructor(bus: EventBus, initialCwd: string);
+    /** Process a chunk of PTY output data. */
+    processData(data: string): void;
+    /** Called when user presses Enter on a non-empty line. */
+    onCommandEntered(command: string, cwd: string): void;
+    /** Returns the full captured prompt bytes, or empty if incomplete. */
+    getLastPrompt(): string;
+    /**
+     * Returns just the last line of the captured prompt (e.g. p10k's "❯ " line).
+     * This is safe to replay with \r because it's linear text (colors + chars),
+     * not relative cursor positioning. Returns empty if no complete capture.
+     */
+    getLastPromptLine(): string;
+    isPromptCaptureComplete(): boolean;
+    isForegroundBusy(): boolean;
+    getCwd(): string;
+    private parseOSC7;
+    /**
+     * Detect our custom prompt marker (OSC 9999) in the PTY stream.
+     * Each time a prompt appears, we finalize the previous command's output.
+     */
+    private parsePromptMarker;
+    /**
+     * Detect end-of-prompt marker (OSC 9998). Finalizes the bracketed capture.
+     *
+     * By the time this runs, the current chunk has already been appended to
+     * promptBuffer (either by parsePromptMarker for the first chunk, or by
+     * the wasCapturing guard in processData for subsequent chunks). So we
+     * just need to trim everything from the end marker onward.
+     */
+    private parsePromptEnd;
+    /**
+     * Strip internal OSC markers from captured prompt so replay is clean.
+     * We intentionally strip all OSC 7 sequences — they're used for cwd
+     * reporting and have no visual effect, so replaying them would just
+     * cause duplicate cwd-change events.
+     */
+    private sanitizePromptForReplay;
+    private removeEchoedCommand;
+}

package/dist/output-parser.js

@@ -0,0 +1,166 @@
+import { stripAnsi } from "./utils/ansi.js";
+/**
+ * Parses PTY output to detect command boundaries, track cwd,
+ * and emit shell events. Owns the command lifecycle state.
+ */
+export class OutputParser {
+    bus;
+    cwd;
+    currentOutputCapture = "";
+    lastCommand = "";
+    foregroundBusy = false;
+    capturingPrompt = false;
+    promptCaptureComplete = false;
+    promptBuffer = "";
+    lastPrompt = "";
+    constructor(bus, initialCwd) {
+        this.bus = bus;
+        this.cwd = initialCwd;
+    }
+    /** Process a chunk of PTY output data. */
+    processData(data) {
+        this.parseOSC7(data);
+        // Bracketed prompt capture: accumulate bytes between OSC 9999 and 9998.
+        // parsePromptMarker may start capture (setting promptBuffer to the tail
+        // of the current chunk), so we only append subsequent chunks here.
+        const wasCapturing = this.capturingPrompt;
+        this.parsePromptMarker(data);
+        // If we were already capturing before this chunk (and still are), append
+        // the full chunk. If capture just started in parsePromptMarker above, the
+        // tail after the start marker is already in promptBuffer — don't double-add.
+        if (wasCapturing && this.capturingPrompt) {
+            this.promptBuffer += data;
+        }
+        // Check for end marker. Must run after the append above so that
+        // multi-chunk captures include this chunk's data before we finalize.
+        this.parsePromptEnd(data);
+    }
+    /** Called when user presses Enter on a non-empty line. */
+    onCommandEntered(command, cwd) {
+        this.lastCommand = command;
+        this.currentOutputCapture = "";
+        this.bus.emit("shell:command-start", { command, cwd });
+        if (!this.foregroundBusy) {
+            this.foregroundBusy = true;
+            this.bus.emit("shell:foreground-busy", { busy: true });
+        }
+    }
+    /** Returns the full captured prompt bytes, or empty if incomplete. */
+    getLastPrompt() {
+        if (!this.promptCaptureComplete)
+            return "";
+        return this.lastPrompt;
+    }
+    /**
+     * Returns just the last line of the captured prompt (e.g. p10k's "❯ " line).
+     * This is safe to replay with \r because it's linear text (colors + chars),
+     * not relative cursor positioning. Returns empty if no complete capture.
+     */
+    getLastPromptLine() {
+        if (!this.promptCaptureComplete)
+            return "";
+        // Find the last \r\n or \n — everything after it is the final prompt line
+        const lastNewline = this.lastPrompt.lastIndexOf("\n");
+        if (lastNewline < 0)
+            return this.lastPrompt;
+        return this.lastPrompt.slice(lastNewline + 1);
+    }
+    isPromptCaptureComplete() {
+        return this.promptCaptureComplete;
+    }
+    isForegroundBusy() {
+        return this.foregroundBusy;
+    }
+    getCwd() {
+        return this.cwd;
+    }
+    // ── Parsing ─────────────────────────────────────────────────
+    parseOSC7(data) {
+        const match = data.match(/\x1b\]7;file:\/\/[^/]*(\/[^\x07\x1b]*)/);
+        if (match?.[1]) {
+            const newCwd = decodeURIComponent(match[1]);
+            if (newCwd !== this.cwd) {
+                this.cwd = newCwd;
+                this.bus.emit("shell:cwd-change", { cwd: this.cwd });
+            }
+        }
+    }
+    /**
+     * Detect our custom prompt marker (OSC 9999) in the PTY stream.
+     * Each time a prompt appears, we finalize the previous command's output.
+     */
+    parsePromptMarker(data) {
+        if (data.includes("\x1b]9999;PROMPT\x07")) {
+            if (this.foregroundBusy) {
+                this.foregroundBusy = false;
+                this.bus.emit("shell:foreground-busy", { busy: false });
+            }
+            if (this.lastCommand) {
+                const output = stripAnsi(this.currentOutputCapture).trim();
+                const cleaned = this.removeEchoedCommand(output, this.lastCommand);
+                this.bus.emit("shell:command-done", {
+                    command: this.lastCommand,
+                    output: cleaned,
+                    cwd: this.cwd,
+                    exitCode: null,
+                });
+            }
+            this.lastCommand = "";
+            this.currentOutputCapture = "";
+            // Start bracketed prompt capture: accumulate bytes until OSC 9998
+            this.capturingPrompt = true;
+            this.promptCaptureComplete = false;
+            this.promptBuffer = "";
+            const markerEnd = data.indexOf("\x1b]9999;PROMPT\x07") + "\x1b]9999;PROMPT\x07".length;
+            if (markerEnd < data.length) {
+                this.promptBuffer = data.slice(markerEnd);
+            }
+        }
+        else {
+            this.currentOutputCapture += data;
+        }
+    }
+    /**
+     * Detect end-of-prompt marker (OSC 9998). Finalizes the bracketed capture.
+     *
+     * By the time this runs, the current chunk has already been appended to
+     * promptBuffer (either by parsePromptMarker for the first chunk, or by
+     * the wasCapturing guard in processData for subsequent chunks). So we
+     * just need to trim everything from the end marker onward.
+     */
+    parsePromptEnd(data) {
+        if (!this.capturingPrompt)
+            return;
+        if (!data.includes("\x1b]9998;READY\x07"))
+            return;
+        // promptBuffer already contains this chunk's data. Find the end marker
+        // within the buffer and trim everything from it onward.
+        const endMarker = "\x1b]9998;READY\x07";
+        const bufEndIdx = this.promptBuffer.indexOf(endMarker);
+        if (bufEndIdx >= 0) {
+            this.promptBuffer = this.promptBuffer.slice(0, bufEndIdx);
+        }
+        this.capturingPrompt = false;
+        this.promptCaptureComplete = true;
+        this.lastPrompt = this.sanitizePromptForReplay(this.promptBuffer);
+    }
+    /**
+     * Strip internal OSC markers from captured prompt so replay is clean.
+     * We intentionally strip all OSC 7 sequences — they're used for cwd
+     * reporting and have no visual effect, so replaying them would just
+     * cause duplicate cwd-change events.
+     */
+    sanitizePromptForReplay(raw) {
+        return raw
+            .replace(/\x1b\]7;[^\x07]*\x07/g, "") // OSC 7 (cwd reporting)
+            .replace(/\x1b\]9999;PROMPT\x07/g, "") // start marker
+            .replace(/\x1b\]9998;READY\x07/g, ""); // end marker
+    }
+    removeEchoedCommand(output, command) {
+        const lines = output.split("\n");
+        if (lines.length > 0 && lines[0].includes(command.slice(0, 20))) {
+            return lines.slice(1).join("\n").trim();
+        }
+        return output;
+    }
+}

package/dist/shell.d.ts

@@ -0,0 +1,54 @@
+import type { EventBus } from "./event-bus.js";
+import { type InputContext } from "./input-handler.js";
+export declare class Shell implements InputContext {
+    private ptyProcess;
+    private bus;
+    private inputHandler;
+    private outputParser;
+    private paused;
+    private agentActive;
+    private tmpDir?;
+    constructor(opts: {
+        bus: EventBus;
+        onShowAgentInfo?: () => {
+            info: string;
+            model?: string;
+        };
+        cols: number;
+        rows: number;
+        shell: string;
+        cwd: string;
+    });
+    isForegroundBusy(): boolean;
+    getCwd(): string;
+    isAgentActive(): boolean;
+    writeToPty(data: string): void;
+    /**
+     * Lightweight redraw: replay just the last line of the shell's prompt
+     * (e.g. p10k's "❯ "). This works because agent input mode only overwrites
+     * the final prompt line — the path bar above is still intact. The last
+     * line is linear text (colors + chars + clear-to-end), no cursor positioning.
+     */
+    redrawPrompt(): void;
+    /**
+     * Heavy redraw: send \n to PTY to trigger a full precmd → prompt cycle.
+     * Use this after agent responses where stdout has moved far from where
+     * zle expects the cursor. The blank line is acceptable as a separator.
+     */
+    freshPrompt(): void;
+    onCommandEntered(command: string, cwd: string): void;
+    private setupOutput;
+    private setupInput;
+    /**
+     * React to agent lifecycle events — Shell manages its own state
+     * rather than being driven by AcpClient. This means AcpClient has
+     * zero frontend knowledge; any frontend can subscribe to the same events.
+     */
+    private setupAgentLifecycle;
+    resize(cols: number, rows: number): void;
+    onExit(callback: (e: {
+        exitCode: number;
+        signal?: number;
+    }) => void): void;
+    kill(): void;
+}