agent-sh 0.3.0 → 0.4.0

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

@@ -0,0 +1,41 @@
+/**
+ * Named handler registry with Emacs-style advice.
+ *
+ * Built-in extensions register named handlers with `define`.
+ * User extensions wrap them with `advise` — each advisor receives
+ * `next` (the previous handler) and decides whether to call it.
+ *
+ *   registry.define("render:code-block", (lang, code) => highlight(lang, code));
+ *
+ *   registry.advise("render:code-block", (next, lang, code) => {
+ *     if (lang === "latex") return renderLatex(code);
+ *     return next(lang, code);  // call original
+ *   });
+ */
+export declare class HandlerRegistry {
+    private handlers;
+    /**
+     * Register a named handler. If one already exists, it's replaced.
+     */
+    define(name: string, fn: (...args: any[]) => any): void;
+    /**
+     * Wrap a named handler with advice. The wrapper receives the
+     * previous handler as `next` and all original arguments.
+     *
+     * - Call `next(...args)` to invoke the original (around/before/after)
+     * - 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.
+     */
+    advise(name: string, wrapper: (next: (...args: any[]) => any, ...args: any[]) => any): void;
+    /**
+     * Call a named handler. Returns undefined if no handler is registered.
+     */
+    call(name: string, ...args: any[]): any;
+    /**
+     * Check if a named handler exists.
+     */
+    has(name: string): boolean;
+}

package/dist/utils/handler-registry.js

@@ -0,0 +1,52 @@
+/**
+ * Named handler registry with Emacs-style advice.
+ *
+ * Built-in extensions register named handlers with `define`.
+ * User extensions wrap them with `advise` — each advisor receives
+ * `next` (the previous handler) and decides whether to call it.
+ *
+ *   registry.define("render:code-block", (lang, code) => highlight(lang, code));
+ *
+ *   registry.advise("render:code-block", (next, lang, code) => {
+ *     if (lang === "latex") return renderLatex(code);
+ *     return next(lang, code);  // call original
+ *   });
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class HandlerRegistry {
+    handlers = new Map();
+    /**
+     * Register a named handler. If one already exists, it's replaced.
+     */
+    define(name, fn) {
+        this.handlers.set(name, fn);
+    }
+    /**
+     * Wrap a named handler with advice. The wrapper receives the
+     * previous handler as `next` and all original arguments.
+     *
+     * - Call `next(...args)` to invoke the original (around/before/after)
+     * - 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.
+     */
+    advise(name, wrapper) {
+        const original = this.handlers.get(name) ?? (() => undefined);
+        this.handlers.set(name, (...args) => wrapper(original, ...args));
+    }
+    /**
+     * Call a named handler. Returns undefined if no handler is registered.
+     */
+    call(name, ...args) {
+        const fn = this.handlers.get(name);
+        return fn?.(...args);
+    }
+    /**
+     * Check if a named handler exists.
+     */
+    has(name) {
+        return this.handlers.has(name);
+    }
+}

package/dist/utils/line-editor.js

@@ -166,6 +166,10 @@ export class LineEditor {
         "ctrl+u": () => this.deleteRange(0, this.cursor),
         "ctrl+k": () => this.deleteRange(this.cursor, this.buffer.length),
         "ctrl+w": () => this.deleteWordBackward() ? { action: "changed" } : null,
+        "alt+f": () => this.wordForward() ? { action: "changed" } : null,
+        "alt+b": () => this.wordBackward() ? { action: "changed" } : null,
+        "alt+d": () => this.deleteWordForward() ? { action: "changed" } : null,
+        "alt+backspace": () => this.deleteWordBackward() ? { action: "changed" } : null,
         "shift+enter": () => this.insertAt("\n"),
         "shift+tab": () => ({ action: "shift+tab" }),
     };

package/dist/utils/markdown.d.ts

@@ -7,15 +7,18 @@ export declare function wrapLine(text: string, maxWidth: number): string[];
  * Streaming markdown renderer that processes chunks of text,
  * renders complete lines with ANSI formatting, and wraps output
  * in a bordered box.
+ *
+ * The renderer accumulates lines internally. Call `drainLines()` to
+ * extract them — this is the only way output leaves the renderer.
  */
 export declare class MarkdownRenderer {
     private buffer;
-    private inCodeBlock;
-    private codeLanguage;
-    private codeLines;
     private contentWidth;
     private firstLine;
-    constructor(terminalWidth?: number);
+    private pendingLines;
+    private width;
+    private tableRows;
+    constructor(width: number);
     /**
      * Push a streaming chunk. Complete lines are rendered immediately;
      * incomplete trailing text stays in the buffer.
@@ -27,13 +30,19 @@ export declare class MarkdownRenderer {
     flush(): void;
     printTopBorder(): void;
     printBottomBorder(): void;
+    /**
+     * Extract and clear all accumulated lines.
+     * This is the only way output leaves the renderer.
+     */
+    drainLines(): string[];
     private processBuffer;
     private processLine;
+    private flushTable;
     private renderLine;
     private renderInline;
-    private renderCodeBlock;
     /**
-     * Write a single line with a subtle left indent.
+     * Add a single line with a subtle left indent.
+     * The line is accumulated internally — call drainLines() to extract.
      */
     writeLine(text: string): void;
 }

package/dist/utils/markdown.js

@@ -1,4 +1,3 @@
-import { highlight } from "cli-highlight";
 import { visibleLen } from "./ansi.js";
 import { palette as p } from "./palette.js";
 const MAX_CONTENT_WIDTH = 90;
@@ -7,6 +6,8 @@ const MAX_CONTENT_WIDTH = 90;
  * Returns an array of lines, each fitting within `maxWidth` visible characters.
  */
 export function wrapLine(text, maxWidth) {
+    if (!(maxWidth > 0))
+        return [text]; // catches NaN, <=0, undefined
     if (visibleLen(text) <= maxWidth)
         return [text];
     const result = [];
@@ -74,18 +75,20 @@ export function wrapLine(text, maxWidth) {
  * Streaming markdown renderer that processes chunks of text,
  * renders complete lines with ANSI formatting, and wraps output
  * in a bordered box.
+ *
+ * The renderer accumulates lines internally. Call `drainLines()` to
+ * extract them — this is the only way output leaves the renderer.
  */
 export class MarkdownRenderer {
     buffer = "";
-    inCodeBlock = false;
-    codeLanguage = "";
-    codeLines = [];
     contentWidth;
     firstLine = true;
-    constructor(terminalWidth) {
-        const termW = terminalWidth ?? (process.stdout.columns || 100);
-        // 2-char left indent for content
-        this.contentWidth = Math.min(MAX_CONTENT_WIDTH, termW - 2);
+    pendingLines = [];
+    width;
+    tableRows = [];
+    constructor(width) {
+        this.width = Math.max(10, width);
+        this.contentWidth = Math.min(MAX_CONTENT_WIDTH, this.width - 2);
     }
     /**
      * Push a streaming chunk. Complete lines are rendered immediately;
@@ -99,22 +102,27 @@ export class MarkdownRenderer {
      * Flush any remaining text in the buffer (called when the response ends).
      */
     flush() {
-        if (this.inCodeBlock) {
-            this.renderCodeBlock();
-        }
         if (this.buffer.length > 0) {
             this.processLine(this.buffer);
             this.buffer = "";
         }
+        this.flushTable();
     }
     printTopBorder() {
-        const termW = process.stdout.columns || 80;
-        process.stdout.write(`${p.dim}${p.accent}${"─".repeat(termW)}${p.reset}\n`);
+        this.pendingLines.push(`${p.dim}${p.accent}${"─".repeat(this.width)}${p.reset}`);
         this.firstLine = true;
     }
     printBottomBorder() {
-        const termW = process.stdout.columns || 80;
-        process.stdout.write(`${p.dim}${p.accent}${"─".repeat(termW)}${p.reset}\n`);
+        this.pendingLines.push(`${p.dim}${p.accent}${"─".repeat(this.width)}${p.reset}`);
+    }
+    /**
+     * Extract and clear all accumulated lines.
+     * This is the only way output leaves the renderer.
+     */
+    drainLines() {
+        const lines = this.pendingLines;
+        this.pendingLines = [];
+        return lines;
     }
     processBuffer() {
         const lines = this.buffer.split("\n");
@@ -124,32 +132,82 @@ export class MarkdownRenderer {
         }
     }
     processLine(line) {
-        // Code fence detection
-        const fenceMatch = line.match(/^(\s*)```(\w*)/);
-        if (fenceMatch) {
-            if (!this.inCodeBlock) {
-                this.inCodeBlock = true;
-                this.codeLanguage = fenceMatch[2] || "";
-                this.codeLines = [];
+        // Table row detection: lines with | separators
+        if (/^\s*\|/.test(line)) {
+            const cells = parseTableRow(line);
+            if (cells) {
+                this.tableRows.push(cells);
                 return;
             }
-            else {
-                this.inCodeBlock = false;
-                this.renderCodeBlock();
-                return;
-            }
-        }
-        if (this.inCodeBlock) {
-            this.codeLines.push(line);
-            return;
         }
+        // Non-table line — flush any buffered table first
+        this.flushTable();
         const rendered = this.renderLine(line);
-        // Word-wrap and output each wrapped line
         const wrapped = wrapLine(rendered, this.contentWidth);
         for (const wl of wrapped) {
             this.writeLine(wl);
         }
     }
+    flushTable() {
+        if (this.tableRows.length === 0)
+            return;
+        const rows = this.tableRows;
+        this.tableRows = [];
+        // Filter out separator rows (|---|---|)
+        const sepIdx = [];
+        const dataRows = [];
+        for (let i = 0; i < rows.length; i++) {
+            if (rows[i].every((c) => /^[-:]+$/.test(c.trim()) || c.trim() === "")) {
+                sepIdx.push(i);
+            }
+            else {
+                dataRows.push(rows[i]);
+            }
+        }
+        if (dataRows.length === 0)
+            return;
+        // Normalize column count
+        const numCols = Math.max(...dataRows.map((r) => r.length));
+        for (const row of dataRows) {
+            while (row.length < numCols)
+                row.push("");
+        }
+        // Calculate column widths from content
+        const colWidths = new Array(numCols).fill(0);
+        for (const row of dataRows) {
+            for (let c = 0; c < numCols; c++) {
+                colWidths[c] = Math.max(colWidths[c], row[c].length);
+            }
+        }
+        // Shrink columns proportionally if total exceeds content width
+        // Account for separators: " │ " between cols (3 chars each) + 2 outer padding
+        const separatorWidth = (numCols - 1) * 3;
+        const availableWidth = this.contentWidth - separatorWidth;
+        const totalWidth = colWidths.reduce((a, b) => a + b, 0);
+        if (totalWidth > availableWidth && availableWidth > numCols) {
+            const scale = availableWidth / totalWidth;
+            for (let c = 0; c < numCols; c++) {
+                colWidths[c] = Math.max(1, Math.floor(colWidths[c] * scale));
+            }
+        }
+        // Render rows
+        const hasHeader = sepIdx.includes(1) && dataRows.length > 1;
+        for (let i = 0; i < dataRows.length; i++) {
+            const row = dataRows[i];
+            const isHeader = hasHeader && i === 0;
+            const cells = row.map((cell, c) => {
+                const w = colWidths[c];
+                const text = cell.length > w ? cell.slice(0, w - 1) + "…" : cell.padEnd(w);
+                return isHeader ? `${p.bold}${text}${p.reset}` : text;
+            });
+            this.writeLine(`${p.dim}│${p.reset} ${cells.join(` ${p.dim}│${p.reset} `)} ${p.dim}│${p.reset}`);
+            // Separator after header
+            if (isHeader) {
+                const sep = colWidths.map((w) => "─".repeat(w)).join(`─┼─`);
+                this.writeLine(`${p.dim}├─${sep}─┤${p.reset}`);
+            }
+        }
+    }
     renderLine(line) {
         if (line.trim() === "")
             return "";
@@ -195,54 +253,35 @@ export class MarkdownRenderer {
         text = text.replace(/\*\*\*(.+?)\*\*\*/g, `${p.bold}${p.italic}$1${p.reset}`);
         // Bold
         text = text.replace(/\*\*(.+?)\*\*/g, `${p.bold}$1${p.reset}`);
-        text = text.replace(/__(.+?)__/g, `${p.bold}$1${p.reset}`);
+        text = text.replace(/(?<!\w)__(.+?)__(?!\w)/g, `${p.bold}$1${p.reset}`);
         // Italic
         text = text.replace(/\*(.+?)\*/g, `${p.italic}$1${p.reset}`);
-        text = text.replace(/_(.+?)_/g, `${p.italic}$1${p.reset}`);
+        text = text.replace(/(?<!\w)_(.+?)_(?!\w)/g, `${p.italic}$1${p.reset}`);
         // Strikethrough
         text = text.replace(/~~(.+?)~~/g, `${p.dim}$1${p.reset}`);
         // Links
         text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, `$1 ${p.muted}${p.underline}($2)${p.reset}`);
         return text;
     }
-    renderCodeBlock() {
-        const code = this.codeLines.join("\n");
-        const lang = this.codeLanguage;
-        if (lang) {
-            this.writeLine(`${p.dim}${lang}${p.reset}`);
-        }
-        let highlighted;
-        try {
-            highlighted = highlight(code, { language: lang || undefined });
-        }
-        catch {
-            highlighted = `${p.success}${code}${p.reset}`;
-        }
-        // Code blocks get indented, and each line is individually wrapped
-        for (const line of highlighted.split("\n")) {
-            const indented = `  ${line}`;
-            const wrapped = wrapLine(indented, this.contentWidth);
-            for (const wl of wrapped) {
-                this.writeLine(wl);
-            }
-        }
-        this.codeLanguage = "";
-        this.codeLines = [];
-    }
     /**
-     * Write a single line with a subtle left indent.
+     * Add a single line with a subtle left indent.
+     * The line is accumulated internally — call drainLines() to extract.
      */
     writeLine(text) {
         if (this.firstLine && visibleLen(text) === 0)
             return;
         this.firstLine = false;
-        process.stdout.write(`  ${text}\n`);
-        if (process.stdout.writable) {
-            try {
-                process.stdout.write('');
-            }
-            catch (e) {
-            }
-        }
+        this.pendingLines.push(`  ${text}`);
     }
 }
+/** Parse a markdown table row into trimmed cell strings, or null if not a table row. */
+function parseTableRow(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|") || !trimmed.endsWith("|"))
+        return null;
+    // Split on |, drop first and last empty entries
+    const parts = trimmed.split("|");
+    if (parts.length < 3)
+        return null; // need at least |cell|
+    return parts.slice(1, -1).map((c) => c.trim());
+}

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

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+export interface OutputWriter {
+    write(text: string): void;
+    get columns(): number;
+}
+/** Default writer that forwards to process.stdout. */
+export declare class StdoutWriter implements OutputWriter {
+    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

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ */
+/** Default writer that forwards to process.stdout. */
+export class StdoutWriter {
+    write(text) {
+        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);
+    }
+}

package/dist/utils/stream-transform.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Stream transform helpers for content pipeline extensions.
+ *
+ * Handles the boilerplate of buffering across chunk boundaries,
+ * pattern matching, and flush-on-done coordination.
+ */
+import type { EventBus, ContentBlock } from "../event-bus.js";
+export interface BlockTransformOptions {
+    /** Opening delimiter (e.g. "$$") */
+    open: string;
+    /** Closing delimiter (e.g. "$$") */
+    close: string;
+    /**
+     * Transform the content between delimiters.
+     * Return a ContentBlock (text, image, or raw) or null to keep original.
+     */
+    transform: (content: string) => ContentBlock | ContentBlock[] | null;
+}
+/**
+ * Register a delimiter-based block transform on the content pipeline.
+ *
+ * Automatically handles:
+ *   - Buffering across chunk boundaries
+ *   - Safe boundary detection (only emits text outside open delimiters)
+ *   - Flush on response-done
+ *
+ * Example:
+ *   createBlockTransform(bus, {
+ *     open: "$$",
+ *     close: "$$",
+ *     transform(latex) {
+ *       const png = renderLatex(latex);
+ *       return png ? { type: "image", data: png } : null;
+ *     },
+ *   });
+ */
+export declare function createBlockTransform(bus: EventBus, opts: BlockTransformOptions): void;
+export interface FencedBlockTransformOptions {
+    /** Regex matching the opening fence line. Captures are passed to transform. */
+    open: RegExp;
+    /** Regex matching the closing fence line. */
+    close: RegExp;
+    /**
+     * Transform a complete fenced block.
+     * Receives the opening fence match and the content between fences.
+     * Return ContentBlock(s), or null to produce a default code-block.
+     */
+    transform: (openMatch: RegExpMatchArray, content: string) => ContentBlock | ContentBlock[] | null;
+}
+/**
+ * Register a line-delimited fenced block transform on the content pipeline.
+ *
+ * Detects patterns like ```lang\n...\n``` in the streaming text,
+ * buffers the content line-by-line, and produces ContentBlocks when
+ * the closing fence arrives.
+ *
+ * Example:
+ *   createFencedBlockTransform(bus, {
+ *     open: /^```(\w*)\s*$/,
+ *     close: /^```\s*$/,
+ *     transform(match, content) {
+ *       return { type: "code-block", language: match[1] || "", code: content };
+ *     },
+ *   });
+ */
+export interface FencedBlockTransformHandle {
+    /** Flush any buffered text (e.g. before tool calls, to preserve interleaving). */
+    flush(): void;
+}
+export declare function createFencedBlockTransform(bus: EventBus, opts: FencedBlockTransformOptions): FencedBlockTransformHandle;