agent-sh 0.8.0 → 0.9.0

package/dist/utils/compositor.js

@@ -0,0 +1,88 @@
+/**
+ * Compositor — routes named render streams to surfaces.
+ *
+ * Components write to named streams ("agent", "query", "status").
+ * The compositor decides where each stream actually goes based on
+ * the current routing table.  Extensions override routing with
+ * `redirect()` to capture output (e.g. overlay panels).
+ *
+ * Streams are hierarchical: "agent:diff" falls back to "agent" if
+ * no override or default is registered for "agent:diff" specifically.
+ * This enables fine-grained interception — redirect just diffs into
+ * a panel, or just a subagent's output ("agent:sub:abc123"), while
+ * everything else flows to the parent stream's surface.
+ *
+ *   // tui-renderer registers default surfaces
+ *   compositor.setDefault("agent", stdoutSurface);
+ *
+ *   // overlay-agent redirects when active
+ *   const restore = compositor.redirect("agent", panelSurface);
+ *   // ... later ...
+ *   restore();  // back to stdout
+ *
+ *   // fine-grained: redirect only diffs to a viewer panel
+ *   compositor.redirect("agent:diff", diffPanelSurface);
+ *   // "agent:text", "agent:tool" etc. still go to stdout
+ */
+/** Silent sink — drops all output. Used when no surface is registered. */
+export const nullSurface = {
+    write() { },
+    writeLine() { },
+    get columns() { return 80; },
+};
+/** Surface backed by process.stdout. */
+export class StdoutSurface {
+    write(text) {
+        if (process.stdout.writable) {
+            try {
+                process.stdout.write(text);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    writeLine(line) {
+        this.write(line + "\n");
+    }
+    get columns() {
+        return process.stdout.columns || 80;
+    }
+}
+export class DefaultCompositor {
+    defaults = new Map();
+    overrides = new Map();
+    surface(stream) {
+        const stack = this.overrides.get(stream);
+        if (stack && stack.length > 0)
+            return stack[stack.length - 1];
+        if (this.defaults.has(stream))
+            return this.defaults.get(stream);
+        // Hierarchical fallback: "agent:diff" → "agent"
+        const colon = stream.lastIndexOf(":");
+        if (colon !== -1)
+            return this.surface(stream.slice(0, colon));
+        return nullSurface;
+    }
+    redirect(stream, target) {
+        let stack = this.overrides.get(stream);
+        if (!stack) {
+            stack = [];
+            this.overrides.set(stream, stack);
+        }
+        stack.push(target);
+        let restored = false;
+        return () => {
+            if (restored)
+                return;
+            restored = true;
+            const s = this.overrides.get(stream);
+            if (!s)
+                return;
+            const idx = s.indexOf(target);
+            if (idx !== -1)
+                s.splice(idx, 1);
+        };
+    }
+    setDefault(stream, target) {
+        this.defaults.set(stream, target);
+    }
+}

package/dist/utils/diff-renderer.js

@@ -254,7 +254,7 @@ function renderUnified(diff, opts) {
         const renderedAsPartOfPair = new Set();
         for (let i = 0; i < hunk.lines.length; i++) {
             const line = hunk.lines[i];
-            const no = String(line.oldNo ?? line.newNo ?? "").padStart(noW);
+            const no = String(line.type === "removed" ? (line.oldNo ?? "") : (line.newNo ?? line.oldNo ?? "")).padStart(noW);
             if (line.type === "context") {
                 const raw = truncateText(line.text, lineTextW);
                 const text = lang ? highlightLine(raw, lang) : raw;
@@ -468,6 +468,91 @@ function truncateText(text, maxWidth) {
     }
     return text.slice(0, i) + p.reset + "…";
 }
+// ── Truncation ──────────────────────────────────────────────────
+/**
+ * Trim context lines from hunks so the rendered output fits within a budget.
+ * Change lines are never removed — only the surrounding context shrinks.
+ */
+function trimHunksToFit(hunks, maxLines) {
+    // Count change lines across all hunks
+    let changeCount = 0;
+    for (const hunk of hunks) {
+        for (const line of hunk.lines) {
+            if (line.type !== "context")
+                changeCount++;
+        }
+    }
+    // Separators between hunks
+    const separators = Math.max(0, hunks.length - 1);
+    // How many context lines can we afford?
+    const contextBudget = Math.max(0, maxLines - changeCount - separators);
+    // Count total context to see if trimming is needed
+    let totalContext = 0;
+    for (const hunk of hunks) {
+        for (const line of hunk.lines) {
+            if (line.type === "context")
+                totalContext++;
+        }
+    }
+    if (totalContext <= contextBudget)
+        return hunks;
+    // Determine how many context lines to keep per side of each change.
+    // Binary-search for the largest per-side context that fits.
+    let lo = 0;
+    let hi = 3; // original context size from groupHunks
+    while (lo < hi) {
+        const mid = Math.ceil((lo + hi) / 2);
+        if (countContextWithLimit(hunks, mid) <= contextBudget)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return rebuildHunks(hunks, lo);
+}
+/** Count how many context lines remain if we keep at most `ctx` per side of each change. */
+function countContextWithLimit(hunks, ctx) {
+    let count = 0;
+    for (const hunk of hunks) {
+        const lines = hunk.lines;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].type !== "context")
+                continue;
+            // Keep this context line if it's within `ctx` of any change
+            let nearChange = false;
+            for (let d = 1; d <= ctx; d++) {
+                if ((i - d >= 0 && lines[i - d].type !== "context") ||
+                    (i + d < lines.length && lines[i + d].type !== "context")) {
+                    nearChange = true;
+                    break;
+                }
+            }
+            if (nearChange)
+                count++;
+        }
+    }
+    return count;
+}
+/** Rebuild hunks keeping only context lines within `ctx` distance of a change. */
+function rebuildHunks(hunks, ctx) {
+    return hunks.map((hunk) => {
+        const lines = hunk.lines;
+        const kept = [];
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].type !== "context") {
+                kept.push(lines[i]);
+                continue;
+            }
+            for (let d = 1; d <= ctx; d++) {
+                if ((i - d >= 0 && lines[i - d].type !== "context") ||
+                    (i + d < lines.length && lines[i + d].type !== "context")) {
+                    kept.push(lines[i]);
+                    break;
+                }
+            }
+        }
+        return { lines: kept };
+    });
+}
 // ── Public API ───────────────────────────────────────────────────
 /** Select display mode based on available terminal width. */
 export function selectMode(width) {
@@ -487,16 +572,19 @@ export function renderDiff(diff, opts) {
     if (mode === "summary") {
         return [header, ...renderSummary(diff)];
     }
+    // Trim context lines from hunks if the diff would exceed the budget,
+    // so that actual changes are always visible.
+    const trimmed = { ...diff, hunks: trimHunksToFit(diff.hunks, maxLines) };
     let bodyLines;
     switch (mode) {
         case "split":
-            bodyLines = renderSplit(diff, opts);
+            bodyLines = renderSplit(trimmed, opts);
             break;
         case "unified":
-            bodyLines = renderUnified(diff, opts);
+            bodyLines = renderUnified(trimmed, opts);
             break;
     }
-    // Truncation
+    // Final safety net — if still over budget, simple tail truncation.
     if (bodyLines.length > maxLines) {
         const overflow = bodyLines.length - maxLines;
         bodyLines = bodyLines.slice(0, maxLines);

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

@@ -182,6 +182,8 @@ export declare class FloatingPanel {
     private ensureBuffer;
     /** Whether the panel has an active conversation (may be hidden). */
     get active(): boolean;
+    /** Whether the agent is currently processing a query. */
+    get processing(): boolean;
     /** Whether the panel is currently visible on screen. */
     get visible(): boolean;
     get terminalBuffer(): TerminalBuffer | null;

package/dist/utils/floating-panel.js

@@ -328,6 +328,10 @@ export class FloatingPanel {
     get active() {
         return this.phase !== "idle";
     }
+    /** Whether the agent is currently processing a query. */
+    get processing() {
+        return this.phase === "active";
+    }
     /** Whether the panel is currently visible on screen. */
     get visible() {
         return this._visible;
@@ -515,7 +519,7 @@ export class FloatingPanel {
         this.render();
     }
     getInput() {
-        return this.editor.buffer;
+        return this.editor.text;
     }
     requestRender() {
         this.scheduleRender();
@@ -634,7 +638,7 @@ export class FloatingPanel {
         for (const action of actions) {
             switch (action.action) {
                 case "submit": {
-                    const query = this.editor.buffer.trim();
+                    const query = this.editor.text.trim();
                     if (!query) {
                         this.hide();
                         return;
@@ -688,8 +692,8 @@ export class FloatingPanel {
             width: geo.contentW,
             height: geo.contentH,
             phase: this.phase,
-            inputBuffer: this.editor.buffer,
-            inputCursor: this.editor.cursor,
+            inputBuffer: this.editor.displayText,
+            inputCursor: this.editor.displayCursor,
             scrollOffset: this.scrollOffset,
             contentLines: this.contentLines,
             partialLine: this.currentPartialLine,
@@ -752,23 +756,35 @@ export class FloatingPanel {
             this.resizeHandler = 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");
         }
-        // ncurses's curscr is stale — only a real dimension change triggers
-        // clearok + full repaint (same-size SIGWINCH is a no-op).
-        const cols = process.stdout.columns || 80;
-        const rows = process.stdout.rows || 24;
-        this.bus.emit("shell:pty-resize", { cols, rows: rows - 1 });
-        setTimeout(() => {
-            this.bus.emit("shell:pty-resize", { cols, rows });
-        }, 50);
-        if (!this.buffer && this.ptyBuffer) {
+        // Replay PTY output that arrived while the overlay was active.
+        // Without this, commands run by the agent (e.g. user_shell ls)
+        // would vanish — the alt screen exit restores the saved screen
+        // from before the overlay opened, losing any shell output produced
+        // during the session.
+        if (this.ptyBuffer) {
             process.stdout.write(this.ptyBuffer);
         }
         this.ptyBuffer = "";
-        this.bus.emit("shell:stdout-hide", {});
         this.bus.emit("shell:stdout-release", {});
+        if (stillInAltScreen || programExited) {
+            // Either a TUI app is still running and needs SIGWINCH to repaint,
+            // 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;
+            this.bus.emit("shell:pty-resize", { cols, rows: rows - 1 });
+            setTimeout(() => {
+                this.bus.emit("shell:pty-resize", { cols, rows });
+            }, 50);
+        }
     }
     // ── Passthrough rendering ─────────────────────────────────
     /** Start rendering TerminalBuffer directly (no overlay box). */

package/dist/utils/handler-registry.d.ts

@@ -11,27 +11,42 @@
  *     if (lang === "latex") return renderLatex(code);
  *     return next(lang, code);  // call original
  *   });
+ *
+ * Internally, each handler is stored as a base function plus an ordered
+ * list of advisors. `call` builds the chain on invocation, so advisors
+ * can be added or removed at any time without closure entanglement.
  */
+type HandlerFn = (...args: any[]) => any;
+type Advisor = (next: HandlerFn, ...args: any[]) => any;
+/** The subset of HandlerRegistry methods available to extensions. */
+export interface HandlerFunctions {
+    define(name: string, fn: (...args: any[]) => any): void;
+    advise(name: string, advisor: (next: (...args: any[]) => any, ...args: any[]) => any): () => void;
+    call(name: string, ...args: any[]): any;
+}
 export declare class HandlerRegistry {
-    private handlers;
+    private entries;
     /**
-     * Register a named handler. If one already exists, it's replaced.
+     * Register a named handler. If one already exists, its base is replaced
+     * but existing advisors are preserved.
      */
-    define(name: string, fn: (...args: any[]) => any): void;
+    define(name: string, fn: HandlerFn): void;
     /**
-     * Wrap a named handler with advice. The wrapper receives the
-     * previous handler as `next` and all original arguments.
+     * Add an advisor to a named handler. The advisor receives `next`
+     * (the rest of the chain) and all original arguments.
      *
-     * - Call `next(...args)` to invoke the original (around/before/after)
+     * - Call `next(...args)` to invoke the rest of the chain
      * - Don't call `next` to replace entirely (override)
      * - Call `next` conditionally to wrap (around)
      *
-     * Multiple advisors chain: each wraps the previous one.
-     * If no handler exists yet, `next` is a no-op.
+     * Advisors run outermost-first (last added = outermost).
+     * Returns an unadvise function that cleanly removes this advisor.
      */
-    advise(name: string, wrapper: (next: (...args: any[]) => any, ...args: any[]) => any): void;
+    advise(name: string, advisor: Advisor): () => void;
     /**
-     * Call a named handler. Returns undefined if no handler is registered.
+     * Call a named handler. Builds the advisor chain on each call:
+     * outermost advisor wraps the next, down to the base handler.
+     * Returns undefined if no handler is registered.
      */
     call(name: string, ...args: any[]): any;
     /**
@@ -39,3 +54,4 @@ export declare class HandlerRegistry {
      */
     has(name: string): boolean;
 }
+export {};

package/dist/utils/handler-registry.js

@@ -11,42 +11,78 @@
  *     if (lang === "latex") return renderLatex(code);
  *     return next(lang, code);  // call original
  *   });
+ *
+ * Internally, each handler is stored as a base function plus an ordered
+ * list of advisors. `call` builds the chain on invocation, so advisors
+ * can be added or removed at any time without closure entanglement.
  */
-/* eslint-disable @typescript-eslint/no-explicit-any */
 export class HandlerRegistry {
-    handlers = new Map();
+    entries = new Map();
     /**
-     * Register a named handler. If one already exists, it's replaced.
+     * Register a named handler. If one already exists, its base is replaced
+     * but existing advisors are preserved.
      */
     define(name, fn) {
-        this.handlers.set(name, fn);
+        const existing = this.entries.get(name);
+        if (existing) {
+            existing.base = fn;
+        }
+        else {
+            this.entries.set(name, { base: fn, advisors: [] });
+        }
     }
     /**
-     * Wrap a named handler with advice. The wrapper receives the
-     * previous handler as `next` and all original arguments.
+     * Add an advisor to a named handler. The advisor receives `next`
+     * (the rest of the chain) and all original arguments.
      *
-     * - Call `next(...args)` to invoke the original (around/before/after)
+     * - Call `next(...args)` to invoke the rest of the chain
      * - Don't call `next` to replace entirely (override)
      * - Call `next` conditionally to wrap (around)
      *
-     * Multiple advisors chain: each wraps the previous one.
-     * If no handler exists yet, `next` is a no-op.
+     * Advisors run outermost-first (last added = outermost).
+     * Returns an unadvise function that cleanly removes this advisor.
      */
-    advise(name, wrapper) {
-        const original = this.handlers.get(name) ?? (() => undefined);
-        this.handlers.set(name, (...args) => wrapper(original, ...args));
+    advise(name, advisor) {
+        let entry = this.entries.get(name);
+        if (!entry) {
+            entry = { base: (() => undefined), advisors: [] };
+            this.entries.set(name, entry);
+        }
+        entry.advisors.push(advisor);
+        let removed = false;
+        return () => {
+            if (removed)
+                return;
+            removed = true;
+            const e = this.entries.get(name);
+            if (!e)
+                return;
+            const idx = e.advisors.indexOf(advisor);
+            if (idx !== -1)
+                e.advisors.splice(idx, 1);
+        };
     }
     /**
-     * Call a named handler. Returns undefined if no handler is registered.
+     * Call a named handler. Builds the advisor chain on each call:
+     * outermost advisor wraps the next, down to the base handler.
+     * Returns undefined if no handler is registered.
      */
     call(name, ...args) {
-        const fn = this.handlers.get(name);
-        return fn?.(...args);
+        const entry = this.entries.get(name);
+        if (!entry)
+            return undefined;
+        // Build chain: base ← advisor[0] ← advisor[1] ← ... ← advisor[n-1]
+        let fn = entry.base;
+        for (const advisor of entry.advisors) {
+            const next = fn;
+            fn = (...a) => advisor(next, ...a);
+        }
+        return fn(...args);
     }
     /**
      * Check if a named handler exists.
      */
     has(name) {
-        return this.handlers.has(name);
+        return this.entries.has(name);
     }
 }

package/dist/utils/line-editor.d.ts

@@ -2,8 +2,14 @@
  * Minimal line editor with readline-style keybindings.
  *
  * Pure logic — no I/O, no rendering, no event bus. Consumers feed raw
- * terminal input bytes and receive high-level actions back. Buffer and
- * cursor state are public for rendering.
+ * terminal input bytes and receive high-level actions back.
+ *
+ * The internal buffer may contain PUA placeholder characters for pasted
+ * multi-line content. Consumers should use the typed accessors:
+ *   - `text`          — resolved content (pastes expanded), for submit/history/logic
+ *   - `displayText`   — display content (pastes collapsed to labels), for rendering
+ *   - `displayCursor` — cursor column in display coordinates
+ *   - `setText()`     — replace buffer content (clears paste attachments)
  */
 export type LineEditAction = {
     action: "changed";
@@ -24,12 +30,26 @@ export type LineEditAction = {
     action: "arrow-down";
 };
 export declare class LineEditor {
-    buffer: string;
+    private _buf;
     cursor: number;
     private pendingSeq;
+    private inPaste;
+    private pasteAccum;
+    private pastes;
+    private pasteCounter;
     private history;
     private historyIndex;
     private savedBuffer;
+    /** Resolved text — paste placeholders expanded. For submit, history, logic. */
+    get text(): string;
+    /** Display text — paste placeholders replaced with labels. For rendering. */
+    get displayText(): string;
+    /** Cursor position mapped to display-text coordinates. */
+    get displayCursor(): number;
+    /** Number of logical positions in the buffer. */
+    get length(): number;
+    /** Replace buffer content. Clears paste attachments. */
+    setText(value: string): void;
     /** Process raw terminal input, return actions for the consumer. */
     feed(data: string): LineEditAction[];
     /** Check if there's a pending incomplete escape sequence. */