agent-sh 0.8.0 → 0.10.0

package/dist/utils/diff.js

@@ -1,9 +1,85 @@
 /**
- * Lightweight LCS-based line diff for file modification previews.
+ * Line-level diff computation, powered by the `diff` npm package.
+ *
+ * Exposes a unified `DiffResult` interface consumed by the diff renderer.
+ * Three entry points cover the main use cases:
+ *
+ *   computeDiff       — full-file diff (write_file, or when edit region can't be located)
+ *   computeEditDiff   — edit_file: locates the edit region, builds the new file, full diff
+ *   computeInputDiff  — fast preview: diffs only old_text vs new_text, no file I/O
  */
+import * as Diff from "diff";
+// ── Helpers ──────────────────────────────────────────────────────────
+/**
+ * Convert a `diff` library Change[] into our DiffLine[], tracking real
+ * old/new line numbers.
+ */
+function changesToDiffLines(changes) {
+    const result = [];
+    let oldNo = 0;
+    let newNo = 0;
+    for (const change of changes) {
+        const lines = change.value.replace(/\n$/, "").split("\n");
+        for (const text of lines) {
+            if (change.added) {
+                newNo++;
+                result.push({ type: "added", oldNo: null, newNo, text });
+            }
+            else if (change.removed) {
+                oldNo++;
+                result.push({ type: "removed", oldNo, newNo: null, text });
+            }
+            else {
+                oldNo++;
+                newNo++;
+                result.push({ type: "context", oldNo, newNo, text });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Group raw DiffLines into hunks with `context` lines of surrounding context.
+ */
+function groupHunks(lines, ctx) {
+    const changeIdx = [];
+    for (let i = 0; i < lines.length; i++)
+        if (lines[i].type !== "context")
+            changeIdx.push(i);
+    if (changeIdx.length === 0)
+        return [];
+    const hunks = [];
+    let start = Math.max(0, changeIdx[0] - ctx);
+    let end = Math.min(lines.length - 1, changeIdx[0] + ctx);
+    for (let k = 1; k < changeIdx.length; k++) {
+        const ns = Math.max(0, changeIdx[k] - ctx);
+        const ne = Math.min(lines.length - 1, changeIdx[k] + ctx);
+        if (ns <= end + 1) {
+            end = ne;
+        }
+        else {
+            hunks.push({ lines: lines.slice(start, end + 1) });
+            start = ns;
+            end = ne;
+        }
+    }
+    hunks.push({ lines: lines.slice(start, end + 1) });
+    return hunks;
+}
+function countChanges(lines) {
+    let added = 0;
+    let removed = 0;
+    for (const l of lines) {
+        if (l.type === "added")
+            added++;
+        else if (l.type === "removed")
+            removed++;
+    }
+    return { added, removed };
+}
+// ── Public API ───────────────────────────────────────────────────────
 /**
  * Compute a line-level diff between old and new file content.
- * Returns grouped hunks with 3 lines of context around each change.
  */
 export function computeDiff(oldText, newText) {
     // New file — everything is an addition
@@ -28,37 +104,11 @@ export function computeDiff(oldText, newText) {
     }
     // Identical — nothing to show
     if (oldText === newText) {
-        return {
-            hunks: [],
-            added: 0,
-            removed: 0,
-            isIdentical: true,
-            isNewFile: false,
-        };
-    }
-    // Build LCS table and backtrack to produce diff lines
-    const a = oldText.split("\n");
-    const b = newText.split("\n");
-    // Bail out if LCS table would be too large (avoids OOM / hang)
-    if (a.length * b.length > 10_000_000) {
-        return {
-            hunks: [],
-            added: b.length,
-            removed: a.length,
-            isIdentical: false,
-            isNewFile: false,
-        };
-    }
-    const dp = buildLcs(a, b);
-    const raw = backtrack(dp, a, b);
-    let added = 0;
-    let removed = 0;
-    for (const l of raw) {
-        if (l.type === "added")
-            added++;
-        else if (l.type === "removed")
-            removed++;
+        return { hunks: [], added: 0, removed: 0, isIdentical: true, isNewFile: false };
     }
+    const changes = Diff.diffLines(oldText, newText);
+    const raw = changesToDiffLines(changes);
+    const { added, removed } = countChanges(raw);
     return {
         hunks: groupHunks(raw, 3),
         added,
@@ -67,66 +117,92 @@ export function computeDiff(oldText, newText) {
         isNewFile: false,
     };
 }
-function buildLcs(a, b) {
-    const m = a.length;
-    const n = b.length;
-    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
-    for (let i = 1; i <= m; i++)
-        for (let j = 1; j <= n; j++)
-            dp[i][j] =
-                a[i - 1] === b[j - 1]
-                    ? dp[i - 1][j - 1] + 1
-                    : Math.max(dp[i - 1][j], dp[i][j - 1]);
-    return dp;
-}
-function backtrack(dp, a, b) {
-    const result = [];
-    let i = a.length;
-    let j = b.length;
-    while (i > 0 || j > 0) {
-        if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
-            result.unshift({ type: "context", oldNo: i, newNo: j, text: a[i - 1] });
-            i--;
-            j--;
-        }
-        else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
-            result.unshift({ type: "added", oldNo: null, newNo: j, text: b[j - 1] });
-            j--;
-        }
-        else {
-            result.unshift({
-                type: "removed",
-                oldNo: i,
-                newNo: null,
-                text: a[i - 1],
-            });
-            i--;
+/**
+ * Compute a diff for an edit operation where we know the old/new text.
+ * Locates the edit region(s) in the file, constructs the full new file,
+ * then diffs the whole thing so line numbers are file-relative.
+ */
+export function computeEditDiff(oldFileText, editOld, editNew, replaceAll = false) {
+    const a = oldFileText.split("\n");
+    const editOldLines = editOld.split("\n");
+    const editNewLines = editNew.split("\n");
+    // Find all occurrences of editOld in the file
+    const regions = [];
+    if (replaceAll) {
+        let i = 0;
+        while (i <= a.length - editOldLines.length) {
+            let match = true;
+            for (let k = 0; k < editOldLines.length; k++) {
+                if (a[i + k] !== editOldLines[k]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                regions.push({ start: i, end: i + editOldLines.length });
+                i += editOldLines.length;
+            }
+            else {
+                i++;
+            }
         }
     }
-    return result;
-}
-function groupHunks(lines, ctx) {
-    const changeIdx = [];
-    for (let i = 0; i < lines.length; i++)
-        if (lines[i].type !== "context")
-            changeIdx.push(i);
-    if (changeIdx.length === 0)
-        return [];
-    const hunks = [];
-    let start = Math.max(0, changeIdx[0] - ctx);
-    let end = Math.min(lines.length - 1, changeIdx[0] + ctx);
-    for (let k = 1; k < changeIdx.length; k++) {
-        const ns = Math.max(0, changeIdx[k] - ctx);
-        const ne = Math.min(lines.length - 1, changeIdx[k] + ctx);
-        if (ns <= end + 1) {
-            end = ne;
+    else {
+        for (let i = 0; i <= a.length - editOldLines.length; i++) {
+            let match = true;
+            for (let k = 0; k < editOldLines.length; k++) {
+                if (a[i + k] !== editOldLines[k]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                regions.push({ start: i, end: i + editOldLines.length });
+                break;
+            }
         }
-        else {
-            hunks.push({ lines: lines.slice(start, end + 1) });
-            start = ns;
-            end = ne;
+    }
+    // Build the full new file
+    let newFile;
+    if (replaceAll && regions.length > 0) {
+        const parts = [];
+        let last = 0;
+        for (const r of regions) {
+            parts.push(...a.slice(last, r.start));
+            parts.push(...editNewLines);
+            last = r.end;
         }
+        parts.push(...a.slice(last));
+        newFile = parts;
     }
-    hunks.push({ lines: lines.slice(start, end + 1) });
-    return hunks;
+    else if (regions.length === 1) {
+        const r = regions[0];
+        newFile = [...a.slice(0, r.start), ...editNewLines, ...a.slice(r.end)];
+    }
+    else {
+        // Couldn't locate edit — fall back to string replace + full diff
+        const newContent = replaceAll
+            ? oldFileText.split(editOld).join(editNew)
+            : oldFileText.replace(editOld, editNew);
+        return computeDiff(oldFileText, newContent);
+    }
+    return computeDiff(oldFileText, newFile.join("\n"));
+}
+/**
+ * Diff two edit strings directly — no file read needed.
+ * Line numbers are relative to the edit region, not the file.
+ * Use for permission prompt previews where speed matters more than
+ * exact file-relative line numbers.
+ */
+export function computeInputDiff(oldText, newText) {
+    const changes = Diff.diffLines(oldText, newText);
+    const raw = changesToDiffLines(changes);
+    const { added, removed } = countChanges(raw);
+    return {
+        hunks: groupHunks(raw, 3),
+        added,
+        removed,
+        isIdentical: false,
+        isNewFile: false,
+    };
 }

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,31 +11,52 @@
  *     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;
+    list(): string[];
+}
 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;
     /**
      * Check if a named handler exists.
      */
     has(name: string): boolean;
+    /**
+     * Names of all registered handlers. For diagnostic/introspection use.
+     */
+    list(): string[];
 }
+export {};

package/dist/utils/handler-registry.js

@@ -11,42 +11,84 @@
  *     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);
+    }
+    /**
+     * Names of all registered handlers. For diagnostic/introspection use.
+     */
+    list() {
+        return [...this.entries.keys()];
     }
 }

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,28 @@ 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 character offset. */
+    get displayCursor(): number;
+    /** Cursor position as visible terminal-column width (accounts for CJK etc.). */
+    get displayCursorWidth(): 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. */
@@ -53,6 +75,14 @@ export declare class LineEditor {
     private handleKittyKey;
     private insertAt;
     private moveTo;
+    /** Move cursor to start of the current logical line. */
+    private moveToLineStart;
+    /** Move cursor to end of the current logical line. */
+    private moveToLineEnd;
+    /** Delete from start of current logical line to cursor (Ctrl+U). */
+    private deleteLineStart;
+    /** Delete from cursor to end of current logical line (Ctrl+K). */
+    private deleteLineEnd;
     private deleteBackward;
     private deleteForward;
     private deleteRange;