agent-sh 0.9.0 → 0.10.1

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/handler-registry.d.ts

@@ -23,6 +23,7 @@ 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 entries;
@@ -53,5 +54,9 @@ export declare class HandlerRegistry {
      * 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

@@ -85,4 +85,10 @@ export class HandlerRegistry {
     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

@@ -44,8 +44,10 @@ export declare class LineEditor {
     get text(): string;
     /** Display text — paste placeholders replaced with labels. For rendering. */
     get displayText(): string;
-    /** Cursor position mapped to display-text coordinates. */
+    /** 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. */
@@ -73,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;

package/dist/utils/line-editor.js

@@ -11,6 +11,7 @@
  *   - `displayCursor` — cursor column in display coordinates
  *   - `setText()`     — replace buffer content (clears paste attachments)
  */
+import { charWidth } from "./ansi.js";
 // ── Kitty protocol keycode → readable name ──────────────────────
 const KITTY_KEY_NAMES = {
     9: "tab", 13: "enter", 27: "escape", 127: "backspace",
@@ -61,7 +62,7 @@ export class LineEditor {
         }
         return result;
     }
-    /** Cursor position mapped to display-text coordinates. */
+    /** Cursor position mapped to display-text character offset. */
     get displayCursor() {
         let pos = 0;
         for (let i = 0; i < this._buf.length && i < this.cursor; i++) {
@@ -77,6 +78,22 @@ export class LineEditor {
         }
         return pos;
     }
+    /** Cursor position as visible terminal-column width (accounts for CJK etc.). */
+    get displayCursorWidth() {
+        let width = 0;
+        for (let i = 0; i < this._buf.length && i < this.cursor; i++) {
+            const ch = this._buf[i];
+            const paste = this.pastes.get(ch.charCodeAt(0) - PUA_BASE);
+            if (paste) {
+                const n = paste.split("\n").length;
+                width += `[paste +${n} lines]`.length; // ASCII-only, 1 col each
+            }
+            else {
+                width += charWidth(ch.codePointAt(0) ?? 0);
+            }
+        }
+        return width;
+    }
     /** Number of logical positions in the buffer. */
     get length() {
         return this._buf.length;
@@ -286,12 +303,12 @@ export class LineEditor {
         "tab": () => ({ action: "tab" }),
         "backspace": () => this.deleteBackward(),
         "ctrl+d": () => this._buf.length === 0 ? { action: "delete-empty" } : this.deleteForward(),
-        "ctrl+a": () => this.moveTo(0),
-        "ctrl+e": () => this.moveTo(this._buf.length),
+        "ctrl+a": () => this.moveToLineStart(),
+        "ctrl+e": () => this.moveToLineEnd(),
         "ctrl+b": () => this.moveTo(this.cursor - 1),
         "ctrl+f": () => this.moveTo(this.cursor + 1),
-        "ctrl+u": () => this.deleteRange(0, this.cursor),
-        "ctrl+k": () => this.deleteRange(this.cursor, this._buf.length),
+        "ctrl+u": () => this.deleteLineStart(),
+        "ctrl+k": () => this.deleteLineEnd(),
         "ctrl+w": () => this.deleteWordBackward() ? { action: "changed" } : null,
         "alt+f": () => this.wordForward() ? { action: "changed" } : null,
         "alt+b": () => this.wordBackward() ? { action: "changed" } : null,
@@ -353,6 +370,28 @@ export class LineEditor {
         this.cursor = clamped;
         return { action: "changed" };
     }
+    /** Move cursor to start of the current logical line. */
+    moveToLineStart() {
+        const lineStart = this._buf.lastIndexOf("\n", this.cursor - 1) + 1;
+        return this.moveTo(lineStart);
+    }
+    /** Move cursor to end of the current logical line. */
+    moveToLineEnd() {
+        const nextNewline = this._buf.indexOf("\n", this.cursor);
+        const lineEnd = nextNewline === -1 ? this._buf.length : nextNewline;
+        return this.moveTo(lineEnd);
+    }
+    /** Delete from start of current logical line to cursor (Ctrl+U). */
+    deleteLineStart() {
+        const lineStart = this._buf.lastIndexOf("\n", this.cursor - 1) + 1;
+        return this.deleteRange(lineStart, this.cursor);
+    }
+    /** Delete from cursor to end of current logical line (Ctrl+K). */
+    deleteLineEnd() {
+        const nextNewline = this._buf.indexOf("\n", this.cursor);
+        const lineEnd = nextNewline === -1 ? this._buf.length : nextNewline;
+        return this.deleteRange(this.cursor, lineEnd);
+    }
     deleteBackward() {
         if (this._buf.length === 0)
             return { action: "delete-empty" };

package/dist/utils/markdown.js

@@ -1,4 +1,4 @@
-import { visibleLen, truncateToWidth, padEndToWidth } from "./ansi.js";
+import { visibleLen, truncateToWidth, padEndToWidth, charWidth } from "./ansi.js";
 import { palette as p } from "./palette.js";
 export const MAX_CONTENT_WIDTH = 90;
 /**
@@ -33,16 +33,31 @@ export function wrapLine(text, maxWidth) {
         for (const word of words) {
             if (word.length === 0)
                 continue;
-            if (currentWidth + word.length <= maxWidth) {
+            const wordWidth = visibleLen(word);
+            if (currentWidth + wordWidth <= maxWidth) {
                 currentLine += word;
-                currentWidth += word.length;
+                currentWidth += wordWidth;
             }
             else if (currentWidth === 0) {
-                // Single word longer than maxWidth — hard break
+                // Single word longer than maxWidth — hard break by visible width
                 let remaining = word;
                 while (remaining.length > 0) {
-                    const chunk = remaining.slice(0, maxWidth - currentWidth || maxWidth);
-                    remaining = remaining.slice(chunk.length);
+                    // Find the largest prefix that fits
+                    let fitLen = 0;
+                    let fitWidth = 0;
+                    for (const ch of remaining) {
+                        const cw = charWidth(ch.codePointAt(0) ?? 0);
+                        if (fitWidth + cw > maxWidth)
+                            break;
+                        fitWidth += cw;
+                        fitLen += ch.length;
+                    }
+                    if (fitLen === 0) {
+                        // Even one char doesn't fit — force take one char to avoid infinite loop
+                        fitLen = remaining[0]?.length ?? 1;
+                    }
+                    const chunk = remaining.slice(0, fitLen);
+                    remaining = remaining.slice(fitLen);
                     currentLine += chunk;
                     if (remaining.length > 0) {
                         result.push(currentLine + p.reset);
@@ -50,7 +65,7 @@ export function wrapLine(text, maxWidth) {
                         currentWidth = 0;
                     }
                     else {
-                        currentWidth += chunk.length;
+                        currentWidth += fitWidth;
                     }
                 }
             }
@@ -62,7 +77,7 @@ export function wrapLine(text, maxWidth) {
                 // Skip leading spaces on new line
                 const trimmed = word.replace(/^ +/, "");
                 currentLine += trimmed;
-                currentWidth = trimmed.length;
+                currentWidth = visibleLen(trimmed);
             }
         }
     }

package/dist/utils/package-version.d.ts

@@ -0,0 +1 @@
+export declare const PACKAGE_VERSION: string;

package/dist/utils/package-version.js

@@ -0,0 +1,10 @@
+/**
+ * The agent-sh package version, read from package.json at load time.
+ * Emitted on `agent:info` so consumers (TUI, remote peers, logs) see a
+ * version that tracks releases instead of a hand-edited constant.
+ */
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+// dist/utils/package-version.js → ../../package.json (project root)
+const pkg = require("../../package.json");
+export const PACKAGE_VERSION = pkg.version ?? "0.0.0";

package/dist/utils/shell-output-spill.d.ts

@@ -0,0 +1,2 @@
+export declare function getSessionDir(): string;
+export declare function spillOutput(id: number, text: string): string;

package/dist/utils/shell-output-spill.js

@@ -0,0 +1,81 @@
+/**
+ * Spill long shell outputs to per-session tempfiles.
+ *
+ * Captured PTY output that exceeds the truncation threshold is written to
+ * `<tmpdir>/agent-sh-<pid>/<id>.out`. The in-memory exchange keeps only a
+ * head+tail stub pointing at that path, so the agent can fetch the full
+ * text via `read_file` on demand. The session dir is removed on process
+ * exit; stale dirs from dead processes are swept lazily on first use.
+ */
+import { mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const DIR_PREFIX = "agent-sh-";
+let sessionDir = null;
+let cleanupRegistered = false;
+export function getSessionDir() {
+    if (sessionDir)
+        return sessionDir;
+    sessionDir = join(tmpdir(), `${DIR_PREFIX}${process.pid}`);
+    mkdirSync(sessionDir, { recursive: true });
+    sweepStaleDirs();
+    if (!cleanupRegistered) {
+        cleanupRegistered = true;
+        const cleanup = () => {
+            if (!sessionDir)
+                return;
+            try {
+                rmSync(sessionDir, { recursive: true, force: true });
+            }
+            catch { }
+            sessionDir = null;
+        };
+        process.on("exit", cleanup);
+        for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+            process.on(sig, () => { cleanup(); process.exit(128); });
+        }
+    }
+    return sessionDir;
+}
+export function spillOutput(id, text) {
+    const path = join(getSessionDir(), `${id}.out`);
+    writeFileSync(path, text);
+    return path;
+}
+function sweepStaleDirs() {
+    const base = tmpdir();
+    let entries;
+    try {
+        entries = readdirSync(base);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        if (!name.startsWith(DIR_PREFIX))
+            continue;
+        const pid = Number(name.slice(DIR_PREFIX.length));
+        if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid)
+            continue;
+        if (isProcessAlive(pid))
+            continue;
+        const full = join(base, name);
+        try {
+            // Small safety check: only remove directories.
+            if (statSync(full).isDirectory()) {
+                rmSync(full, { recursive: true, force: true });
+            }
+        }
+        catch { }
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        // ESRCH = no such process; EPERM = exists but we can't signal it
+        return e.code === "EPERM";
+    }
+}

package/dist/utils/tool-display.d.ts

@@ -27,7 +27,7 @@ export interface ToolResultRender {
 }
 export declare function isQuietCommand(command: string): boolean;
 export declare function selectToolDisplayMode(width: number): ToolDisplayMode;
-export declare function renderToolCall(tool: ToolCallRender, width: number): string[];
+export declare function renderToolCall(tool: ToolCallRender, width: number, cwd?: string): string[];
 export declare function renderToolResult(result: ToolResultRender, width: number): string[];
 export declare function formatElapsed(ms: number): string;
 export declare const SPINNER_FRAMES: string[];

package/dist/utils/tool-display.js

@@ -39,7 +39,6 @@ const KIND_ICONS = {
     move: "↗",
     search: "⌕",
     execute: "▶",
-    display: "◇",
     think: "◇",
     fetch: "↓",
     switch_mode: "⇄",
@@ -48,7 +47,7 @@ function kindIcon(kind) {
     return kind ? (KIND_ICONS[kind] ?? "▶") : "▶";
 }
 // ── Tool call rendering ──────────────────────────────────────────
-export function renderToolCall(tool, width) {
+export function renderToolCall(tool, width, cwd = process.cwd()) {
     const mode = selectToolDisplayMode(width);
     const icon = tool.icon ?? kindIcon(tool.kind);
     // If the tool registered a custom icon, it's self-describing — omit the name.
@@ -61,7 +60,6 @@ export function renderToolCall(tool, width) {
     const lines = [];
     // Build a compact detail string to append after the title
     let detail = "";
-    const cwd = process.cwd();
     if (mode === "full" && tool.displayDetail) {
         detail = tool.displayDetail;
     }
@@ -70,7 +68,7 @@ export function renderToolCall(tool, width) {
             detail = `$ ${tool.command}`;
         }
         else if (tool.locations && tool.locations.length > 0) {
-            const loc = tool.locations[0];
+            const loc = tool.locations.find((l) => l?.path) ?? tool.locations[0];
             const lineInfo = loc.line ? `:${loc.line}` : "";
             detail = `${shortenPath(loc.path, cwd)}${lineInfo}`;
         }
@@ -227,6 +225,8 @@ export function renderSpinnerLine(state, label, opts) {
  * Shorten an absolute path to a relative or tilde-prefixed form.
  */
 function shortenPath(p, cwd) {
+    if (!p || typeof p !== "string")
+        return "";
     if (p.startsWith(cwd + "/"))
         return p.slice(cwd.length + 1);
     if (p.startsWith(cwd))

package/examples/extensions/ash-acp-bridge/src/index.ts

@@ -411,7 +411,6 @@ async function handleSessionNew(id: number | string, params: Record<string, unkn
     const headlessDisabled = [
       "tui-renderer",
       "file-autocomplete",
-      "terminal-buffer",
       "overlay-agent",
       ...(settings.disabledBuiltins ?? []),
     ];
@@ -428,6 +427,10 @@ async function handleSessionNew(id: number | string, params: Record<string, unkn
       process.stderr.write(`Warning: ${err instanceof Error ? err.message : err}\n`);
     });
 
+    // Signal deferred-init listeners (agent-backend) that the provider
+    // registry is complete — they resolve their LLM config on this event.
+    core.bus.emit("core:extensions-loaded", {});
+
     core.activateBackend();
   }