agent-sh 0.12.2 → 0.12.4

package/dist/shell/tui-input-view.js

@@ -0,0 +1,140 @@
+/**
+ * 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 { visibleLen } from "../utils/ansi.js";
+import { palette as p } from "../utils/palette.js";
+import { StdoutSurface } from "../utils/compositor.js";
+export class TuiInputView {
+    cursorRowsBelow = 0;
+    cursorTermCol = 1;
+    autocompleteLines = 0;
+    surface;
+    constructor(surface) {
+        this.surface = surface ?? new StdoutSurface();
+    }
+    resetCursor() {
+        this.cursorRowsBelow = 0;
+        this.cursorTermCol = 1;
+    }
+    enableModeKeys() {
+        // Kitty progressive enhancement + bracket paste (Shift+Enter → \x1b[13;2u).
+        this.surface.write("\x1b[>1u\x1b[?2004h");
+    }
+    disableModeKeys() {
+        this.surface.write("\x1b[<u\x1b[?2004l");
+    }
+    clearPromptArea() {
+        if (this.cursorRowsBelow > 0) {
+            this.surface.write(`\x1b[${this.cursorRowsBelow}A`);
+        }
+        this.surface.write("\r\x1b[J");
+        this.cursorRowsBelow = 0;
+    }
+    drawPrompt(vm) {
+        const termW = this.surface.columns;
+        if (this.cursorRowsBelow > 0) {
+            this.surface.write(`\x1b[${this.cursorRowsBelow}A`);
+        }
+        this.surface.write("\r\x1b[J");
+        const infoPrefix = vm.agentInfo.info
+            ? `${vm.agentInfo.info} ${p.success}${vm.indicator}${p.reset} `
+            : `${p.success}${vm.indicator}${p.reset} `;
+        const promptPrefix = infoPrefix + p.warning + p.bold + vm.promptIcon + " " + p.reset;
+        const promptVisLen = visibleLen(infoPrefix) + visibleLen(vm.promptIcon) + 1;
+        const display = vm.showBuffer ? vm.displayText : "";
+        const dCursor = vm.showBuffer ? vm.displayCursor : 0;
+        if (!vm.showBuffer) {
+            this.surface.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")) {
+            // DECSC/DECRC bracket the after-cursor text so the cursor lands mid-line.
+            const before = display.slice(0, dCursor);
+            const after = display.slice(dCursor);
+            this.surface.write(promptPrefix + p.accent + before + p.reset +
+                "\x1b7" +
+                p.accent + after + p.reset +
+                "\x1b8");
+            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 {
+            const lines = display.split("\n");
+            const indent = " ".repeat(promptVisLen);
+            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;
+                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) {
+                    const before = lineText.slice(0, charsRemaining);
+                    const after = lineText.slice(charsRemaining);
+                    output += prefix + p.accent + before + p.reset;
+                    output += "\x1b7";
+                    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;
+            }
+            this.surface.write(output + "\x1b8");
+            this.cursorRowsBelow = cursorRowFromTop;
+        }
+    }
+    drawAutocomplete(vm) {
+        if (vm.items.length === 0)
+            return;
+        const lines = [];
+        for (let i = 0; i < vm.items.length; i++) {
+            const item = vm.items[i];
+            const selected = i === vm.selected;
+            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}`);
+            }
+        }
+        this.surface.write("\n" + lines.join("\n"));
+        this.autocompleteLines = lines.length;
+        if (this.autocompleteLines > 0) {
+            this.surface.write(`\x1b[${this.autocompleteLines}A`);
+        }
+        // Absolute column set — preceding \n may have scrolled, invalidating DECSC.
+        this.surface.write(`\x1b[${this.cursorTermCol}G`);
+    }
+    clearAutocomplete() {
+        if (this.autocompleteLines <= 0)
+            return;
+        // CSI B (cursor down, bounded) so we don't scroll on the last row.
+        for (let i = 0; i < this.autocompleteLines; i++) {
+            this.surface.write("\x1b[B\x1b[2K");
+        }
+        this.surface.write(`\x1b[${this.autocompleteLines}A\x1b[${this.cursorTermCol}G`);
+        this.autocompleteLines = 0;
+    }
+}

package/dist/types.d.ts

@@ -48,6 +48,9 @@ export interface AgentMode {
     reasoning?: boolean;
     /** Provider supports the reasoning_effort parameter. */
     supportsReasoningEffort?: boolean;
+    /** Echo reasoning_content back on assistant turns. Required by DeepSeek;
+     *  default off (leaky shims may forward it to the model as OOD input). */
+    echoReasoning?: boolean;
 }
 /**
  * Backend-agnostic LLM interface exposed via `ctx.llm`. Backends fulfill it
@@ -146,6 +149,9 @@ export interface ExtensionContext {
      * Extensions use `compositor.redirect()` to capture output (e.g. overlay panels).
      */
     compositor: Compositor;
+    /** Teardown callback fired on /reload. For resources the scoped context
+     *  can't track: process listeners, timers, watchers, sockets. */
+    onDispose: (fn: () => void) => void;
     /**
      * Create a remote session that routes agent output to a surface and
      * optionally accepts queries. Handles all compositor routing, shell

package/dist/utils/compositor.d.ts

@@ -36,6 +36,10 @@ export interface RenderSurface {
     writeLine(line: string): void;
     /** Available width in columns. */
     readonly columns: number;
+    /** Available height in rows. */
+    readonly rows: number;
+    /** Subscribe to size changes. Returns unsubscribe. */
+    onResize(cb: (cols: number, rows: number) => void): () => void;
 }
 export interface Compositor {
     /** Get the currently active surface for a stream. */
@@ -48,11 +52,13 @@ export interface Compositor {
 }
 /** Silent sink — drops all output. Used when no surface is registered. */
 export declare const nullSurface: RenderSurface;
-/** Surface backed by process.stdout. */
+/** Surface backed by process.stdout — the only sanctioned bridge to it. */
 export declare class StdoutSurface implements RenderSurface {
     write(text: string): void;
     writeLine(line: string): void;
     get columns(): number;
+    get rows(): number;
+    onResize(cb: (cols: number, rows: number) => void): () => void;
 }
 export declare class DefaultCompositor implements Compositor {
     private defaults;

package/dist/utils/compositor.js

@@ -29,8 +29,10 @@ export const nullSurface = {
     write() { },
     writeLine() { },
     get columns() { return 80; },
+    get rows() { return 24; },
+    onResize() { return () => { }; },
 };
-/** Surface backed by process.stdout. */
+/** Surface backed by process.stdout — the only sanctioned bridge to it. */
 export class StdoutSurface {
     write(text) {
         if (process.stdout.writable) {
@@ -46,6 +48,14 @@ export class StdoutSurface {
     get columns() {
         return process.stdout.columns || 80;
     }
+    get rows() {
+        return process.stdout.rows || 24;
+    }
+    onResize(cb) {
+        const handler = () => cb(this.columns, this.rows);
+        process.stdout.on("resize", handler);
+        return () => { process.stdout.off("resize", handler); };
+    }
 }
 export class DefaultCompositor {
     defaults = new Map();
@@ -111,6 +121,8 @@ export class DefaultCompositor {
                 target.writeLine(line);
             },
             get columns() { return target.columns; },
+            get rows() { return target.rows; },
+            onResize: (cb) => target.onResize(cb),
         };
     }
 }

package/dist/utils/floating-panel.d.ts

@@ -2,6 +2,7 @@ import { TerminalBuffer } from "./terminal-buffer.js";
 import { HandlerRegistry } from "./handler-registry.js";
 import type { EventBus } from "../event-bus.js";
 import type { BorderStyle } from "./box-frame.js";
+import { type RenderSurface } from "./compositor.js";
 export interface FloatingPanelConfig {
     /** Key sequence that toggles the panel (e.g. "\x1c" for Ctrl+\). */
     trigger: string;
@@ -36,6 +37,8 @@ export interface FloatingPanelConfig {
      * `{prefix}:submit`, etc. Use different prefixes for multiple panels.
      */
     handlerPrefix?: string;
+    /** Render sink + viewport. Defaults to a fresh StdoutSurface. */
+    surface?: RenderSurface;
 }
 /**
  * Context passed to the render-content handler.
@@ -129,6 +132,7 @@ export type Phase = "idle" | "input" | "active" | "done";
 export declare class FloatingPanel {
     private readonly config;
     private readonly bus;
+    private readonly surface;
     private readonly border;
     private readonly externalBuffer;
     private readonly prefix;
@@ -164,7 +168,7 @@ export declare class FloatingPanel {
     private title;
     private footer;
     private renderTimer;
-    private resizeHandler;
+    private resizeUnsub;
     private prevFrame;
     private suppressNextRedraw;
     private autoDismissTimer;
@@ -213,7 +217,7 @@ export declare class FloatingPanel {
     /** Handle scroll input. Returns true if consumed. */
     private handleScroll;
     private handleInputKey;
-    /** Compute box geometry from config + current terminal size. */
+    /** Compute box geometry from config + current viewport. */
     computeGeometry(): BoxGeometry;
     private buildFrame;
     private scheduleRender;

package/dist/utils/floating-panel.js

@@ -35,6 +35,7 @@ import { wrapLine } from "./markdown.js";
 import { LineEditor } from "./line-editor.js";
 import { TerminalBuffer } from "./terminal-buffer.js";
 import { HandlerRegistry } from "./handler-registry.js";
+import { StdoutSurface } from "./compositor.js";
 // ── ANSI constants ──────────────────────────────────────────────
 const DIM = "\x1b[2m";
 const RESET = "\x1b[0m";
@@ -74,6 +75,7 @@ export class FloatingPanel {
     // ── Configuration ───────────────────────────────────────────
     config;
     bus;
+    surface;
     border;
     externalBuffer;
     prefix;
@@ -112,7 +114,7 @@ export class FloatingPanel {
     title = "";
     footer = "";
     renderTimer = null;
-    resizeHandler = null;
+    resizeUnsub = null;
     prevFrame = [];
     suppressNextRedraw = false;
     autoDismissTimer = null;
@@ -124,6 +126,7 @@ export class FloatingPanel {
     prevSerialized = "";
     constructor(bus, config, handlers) {
         this.bus = bus;
+        this.surface = config.surface ?? new StdoutSurface();
         this.externalBuffer = config.terminalBuffer;
         this.prefix = config.handlerPrefix ?? "panel";
         this.handlers = handlers ?? new HandlerRegistry();
@@ -436,10 +439,9 @@ export class FloatingPanel {
         this.bus.emit("shell:stdout-hold", {});
         this.usedAltScreen = !(this.buffer?.altScreen);
         if (this.usedAltScreen) {
-            process.stdout.write("\x1b[?1049h");
+            this.surface.write("\x1b[?1049h");
         }
-        this.resizeHandler = () => { this.prevFrame = []; this.render(); };
-        process.stdout.on("resize", this.resizeHandler);
+        this.resizeUnsub = this.surface.onResize(() => { this.prevFrame = []; this.render(); });
         this.render();
     }
     // ── Public content API ──────────────────────────────────────
@@ -674,10 +676,10 @@ export class FloatingPanel {
         }
     }
     // ── Geometry ───────────────────────────────────────────────
-    /** Compute box geometry from config + current terminal size. */
+    /** Compute box geometry from config + current viewport. */
     computeGeometry() {
-        const cols = process.stdout.columns || 80;
-        const rows = process.stdout.rows || 24;
+        const cols = this.surface.columns;
+        const rows = this.surface.rows;
         const boxW = Math.min(this.resolveSize(this.config.width, cols - 4), this.config.maxWidth);
         const boxH = Math.min(this.resolveSize(this.config.height, rows - 4), Math.max(this.config.minHeight + 2, rows - 4));
         const boxTop = Math.floor((rows - boxH) / 2);
@@ -744,24 +746,22 @@ export class FloatingPanel {
             out.push(cursorSeq);
         out.push(SYNC_END);
         if (this.prevFrame.length === 0 || dirty) {
-            process.stdout.write(out.join(""));
+            this.surface.write(out.join(""));
         }
         this.prevFrame = frame;
     }
     // ── Screen helpers ────────────────────────────────────────
     /** Full screen teardown: exit alt screen, release stdout, force redraw. */
     teardownScreen() {
-        if (this.resizeHandler) {
-            process.stdout.off("resize", this.resizeHandler);
-            this.resizeHandler = null;
-        }
+        this.resizeUnsub?.();
+        this.resizeUnsub = null;
         this.suppressNextRedraw = true;
         // Re-check alt screen state: the program we overlaid may have exited
         // (e.g. agent quit vim via terminal_keys) while the panel was active.
         const stillInAltScreen = !this.usedAltScreen && !!this.buffer?.altScreen;
         const programExited = !this.usedAltScreen && !stillInAltScreen;
         if (this.usedAltScreen) {
-            process.stdout.write("\x1b[?1049l");
+            this.surface.write("\x1b[?1049l");
         }
         // Replay PTY output that arrived while the overlay was active.
         // Without this, commands run by the agent (e.g. user_shell ls)
@@ -769,7 +769,7 @@ export class FloatingPanel {
         // from before the overlay opened, losing any shell output produced
         // during the session.
         if (this.ptyBuffer) {
-            process.stdout.write(this.ptyBuffer);
+            this.surface.write(this.ptyBuffer);
         }
         this.ptyBuffer = "";
         this.bus.emit("shell:stdout-release", {});
@@ -778,8 +778,8 @@ export class FloatingPanel {
             // or the overlaid program exited (e.g. agent quit vim) and we
             // discarded its stale buffer — SIGWINCH makes the shell redraw
             // its prompt cleanly.
-            const cols = process.stdout.columns || 80;
-            const rows = process.stdout.rows || 24;
+            const cols = this.surface.columns;
+            const rows = this.surface.rows;
             this.bus.emit("shell:pty-resize", { cols, rows: rows - 1 });
             setTimeout(() => {
                 this.bus.emit("shell:pty-resize", { cols, rows });
@@ -808,7 +808,7 @@ export class FloatingPanel {
         const serialized = this.buffer.serialize();
         if (serialized && serialized !== this.prevSerialized) {
             this.prevSerialized = serialized;
-            process.stdout.write(`${SYNC_START}\x1b[H${serialized}${SYNC_END}`);
+            this.surface.write(`${SYNC_START}\x1b[H${serialized}${SYNC_END}`);
         }
     }
     resolveSize(spec, available) {

package/dist/utils/ref-counter.d.ts

@@ -0,0 +1,9 @@
+/** Simple ref-counted counter. Increment/decrement never goes below zero. */
+export declare class RefCounter {
+    private count;
+    increment(): void;
+    decrement(): void;
+    reset(): void;
+    get active(): boolean;
+    get value(): number;
+}

package/dist/utils/ref-counter.js

@@ -0,0 +1,9 @@
+/** Simple ref-counted counter. Increment/decrement never goes below zero. */
+export class RefCounter {
+    count = 0;
+    increment() { this.count++; }
+    decrement() { this.count = Math.max(0, this.count - 1); }
+    reset() { this.count = 0; }
+    get active() { return this.count > 0; }
+    get value() { return this.count; }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.12.2",
+  "version": "0.12.4",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core.js",

package/dist/utils/frame-renderer.d.ts

@@ -1,26 +0,0 @@
-/**
- * Differential frame renderer.
- *
- * Accepts a frame (string[]) and writes only the lines that changed
- * compared to the previous frame.  Designed for scrolling content
- * (not full-screen ownership like pi-tui).
- *
- * Fast paths:
- *   1. First render → write everything
- *   2. Append-only → write only new lines
- *   3. Last line changed → \r overwrite (for spinner / partial streaming)
- *   4. General diff → cursor-up, rewrite changed region, cursor-down
- */
-import type { OutputWriter } from "./output-writer.js";
-export declare class FrameRenderer {
-    private writer;
-    private prevLines;
-    constructor(writer: OutputWriter);
-    /**
-     * Render a new frame, writing only the diff to the output.
-     * Each line in `lines` should NOT include a trailing newline.
-     */
-    update(lines: string[]): void;
-    /** Reset state — next update will be treated as a first render. */
-    reset(): void;
-}

package/dist/utils/frame-renderer.js

@@ -1,76 +0,0 @@
-export class FrameRenderer {
-    writer;
-    prevLines = [];
-    constructor(writer) {
-        this.writer = writer;
-    }
-    /**
-     * Render a new frame, writing only the diff to the output.
-     * Each line in `lines` should NOT include a trailing newline.
-     */
-    update(lines) {
-        const prev = this.prevLines;
-        if (prev.length === 0) {
-            // Fast path 1: first render
-            for (const line of lines) {
-                this.writer.write(line + "\n");
-            }
-            this.prevLines = lines.slice();
-            return;
-        }
-        // Find first and last changed indices
-        const minLen = Math.min(prev.length, lines.length);
-        let firstChanged = -1;
-        let lastChanged = -1;
-        for (let i = 0; i < minLen; i++) {
-            if (prev[i] !== lines[i]) {
-                if (firstChanged === -1)
-                    firstChanged = i;
-                lastChanged = i;
-            }
-        }
-        // Check for appended or removed lines
-        const appended = lines.length > prev.length;
-        const truncated = lines.length < prev.length;
-        if (firstChanged === -1 && !appended && !truncated) {
-            // No changes at all
-            this.prevLines = lines.slice();
-            return;
-        }
-        if (firstChanged === -1 && appended) {
-            // Fast path 2: only new lines appended, existing unchanged
-            for (let i = prev.length; i < lines.length; i++) {
-                this.writer.write(lines[i] + "\n");
-            }
-            this.prevLines = lines.slice();
-            return;
-        }
-        // General diff: move cursor up to first changed line, rewrite
-        const linesFromBottom = prev.length - (firstChanged === -1 ? prev.length : firstChanged);
-        if (linesFromBottom > 0) {
-            this.writer.write(`\x1b[${linesFromBottom}A`); // cursor up
-        }
-        this.writer.write("\r"); // start of line
-        // Rewrite from firstChanged to end of new frame
-        const start = firstChanged === -1 ? prev.length : firstChanged;
-        for (let i = start; i < lines.length; i++) {
-            this.writer.write(`\x1b[2K${lines[i]}\n`); // clear line + write + newline
-        }
-        // If new frame is shorter, clear remaining old lines
-        if (truncated) {
-            for (let i = lines.length; i < prev.length; i++) {
-                this.writer.write("\x1b[2K\n");
-            }
-            // Move cursor back up to end of new content
-            const extra = prev.length - lines.length;
-            if (extra > 0) {
-                this.writer.write(`\x1b[${extra}A`);
-            }
-        }
-        this.prevLines = lines.slice();
-    }
-    /** Reset state — next update will be treated as a first render. */
-    reset() {
-        this.prevLines = [];
-    }
-}

package/dist/utils/output-writer.d.ts

@@ -1,36 +0,0 @@
-/**
- * Abstraction over terminal output.
- *
- * All TUI rendering goes through an OutputWriter instead of calling
- * process.stdout.write directly.  This enables testing (BufferWriter),
- * alternative frontends, and a single point of control for output.
- */
-/** Simple ref-counted counter. Increment/decrement never goes below zero. */
-export declare class RefCounter {
-    private count;
-    increment(): void;
-    decrement(): void;
-    reset(): void;
-    get active(): boolean;
-    get value(): number;
-}
-export interface OutputWriter {
-    write(text: string): void;
-    get columns(): number;
-}
-/** Default writer that forwards to process.stdout. */
-export declare class StdoutWriter implements OutputWriter {
-    /** When > 0, all writes are silently dropped. Ref-counted. */
-    private readonly _hold;
-    hold(): void;
-    release(): void;
-    get held(): boolean;
-    write(text: string): void;
-    get columns(): number;
-}
-/** Captures all output in memory. Useful for testing. */
-export declare class BufferWriter implements OutputWriter {
-    output: string[];
-    columns: number;
-    write(text: string): void;
-}

package/dist/utils/output-writer.js

@@ -1,45 +0,0 @@
-/**
- * Abstraction over terminal output.
- *
- * All TUI rendering goes through an OutputWriter instead of calling
- * process.stdout.write directly.  This enables testing (BufferWriter),
- * alternative frontends, and a single point of control for output.
- */
-/** Simple ref-counted counter. Increment/decrement never goes below zero. */
-export class RefCounter {
-    count = 0;
-    increment() { this.count++; }
-    decrement() { this.count = Math.max(0, this.count - 1); }
-    reset() { this.count = 0; }
-    get active() { return this.count > 0; }
-    get value() { return this.count; }
-}
-/** Default writer that forwards to process.stdout. */
-export class StdoutWriter {
-    /** When > 0, all writes are silently dropped. Ref-counted. */
-    _hold = new RefCounter();
-    hold() { this._hold.increment(); }
-    release() { this._hold.decrement(); }
-    get held() { return this._hold.active; }
-    write(text) {
-        if (this._hold.active)
-            return;
-        if (process.stdout.writable) {
-            try {
-                process.stdout.write(text);
-            }
-            catch { }
-        }
-    }
-    get columns() {
-        return process.stdout.columns || 80;
-    }
-}
-/** Captures all output in memory. Useful for testing. */
-export class BufferWriter {
-    output = [];
-    columns = 80;
-    write(text) {
-        this.output.push(text);
-    }
-}