agent-sh 0.3.0 → 0.3.1

package/dist/settings.d.ts

@@ -28,6 +28,17 @@ export interface Settings {
 declare const DEFAULTS: Required<Settings>;
 /** Load settings from disk (cached after first call). */
 export declare function getSettings(): Settings & typeof DEFAULTS;
+/**
+ * Get settings for an extension, namespaced under its key in settings.json.
+ *
+ * Example settings.json:
+ *   { "latex-images": { "dpi": 600, "fgColor": "ffffff" } }
+ *
+ * Usage in extension:
+ *   const config = getExtensionSettings("latex-images", { dpi: 300, fgColor: "d4d4d4" });
+ *   // config.dpi === 600 (overridden), config.fgColor === "ffffff" (overridden)
+ */
+export declare function getExtensionSettings<T extends Record<string, unknown>>(namespace: string, defaults: T): T;
 /** Reset cached settings (for testing or after external edit). */
 export declare function reloadSettings(): void;
 export {};

package/dist/settings.js

@@ -18,7 +18,7 @@ const DEFAULTS = {
     shellHeadLines: 5,
     shellTailLines: 5,
     recallExpandMaxLines: 100,
-    maxCommandOutputLines: 5,
+    maxCommandOutputLines: 3,
     readOutputMaxLines: 0,
     diffMaxLines: 20,
     enableMcp: true,
@@ -37,6 +37,24 @@ export function getSettings() {
     }
     return { ...DEFAULTS, ...cached };
 }
+/**
+ * Get settings for an extension, namespaced under its key in settings.json.
+ *
+ * Example settings.json:
+ *   { "latex-images": { "dpi": 600, "fgColor": "ffffff" } }
+ *
+ * Usage in extension:
+ *   const config = getExtensionSettings("latex-images", { dpi: 300, fgColor: "d4d4d4" });
+ *   // config.dpi === 600 (overridden), config.fgColor === "ffffff" (overridden)
+ */
+export function getExtensionSettings(namespace, defaults) {
+    const all = getSettings();
+    const ext = all[namespace];
+    if (ext && typeof ext === "object" && !Array.isArray(ext)) {
+        return { ...defaults, ...ext };
+    }
+    return defaults;
+}
 /** Reset cached settings (for testing or after external edit). */
 export function reloadSettings() {
     cached = null;

package/dist/types.d.ts

@@ -2,6 +2,9 @@ import type { EventBus } from "./event-bus.js";
 import type { ContextManager } from "./context-manager.js";
 import type { AcpClient } from "./acp-client.js";
 import type { ColorPalette } from "./utils/palette.js";
+import type { BlockTransformOptions, FencedBlockTransformOptions } from "./utils/stream-transform.js";
+export type { ContentBlock } from "./event-bus.js";
+export type { BlockTransformOptions, FencedBlockTransformOptions } from "./utils/stream-transform.js";
 export interface AgentShellConfig {
     agentCommand: string;
     agentArgs: string[];
@@ -24,6 +27,18 @@ export interface ExtensionContext {
     quit: () => void;
     /** Override color palette slots for theming. */
     setPalette: (overrides: Partial<ColorPalette>) => void;
+    /** Register a delimiter-based content transform (e.g. $$...$$ → image). */
+    createBlockTransform: (opts: BlockTransformOptions) => void;
+    /** Register a fenced block transform (e.g. ```lang...``` → code-block). */
+    createFencedBlockTransform: (opts: FencedBlockTransformOptions) => void;
+    /** Read extension-namespaced settings from ~/.agent-sh/settings.json. */
+    getExtensionSettings: <T extends Record<string, unknown>>(namespace: string, defaults: T) => T;
+    /** Register a named handler. */
+    define: (name: string, fn: (...args: any[]) => any) => void;
+    /** Wrap a named handler. Receives `next` (original) + args. */
+    advise: (name: string, wrapper: (next: (...args: any[]) => any, ...args: any[]) => any) => void;
+    /** Call a named handler. */
+    call: (name: string, ...args: any[]) => any;
 }
 export interface TerminalSession {
     id: string;

package/dist/utils/box-frame.js

@@ -22,7 +22,8 @@ const BORDERS = {
  * @returns Array of terminal-ready lines with borders
  */
 export function renderBoxFrame(content, opts) {
-    const { width, borderColor = p.dim } = opts;
+    const { width: rawWidth, borderColor = p.dim } = opts;
+    const width = Math.max(6, rawWidth);
     const style = opts.style ?? "rounded";
     const b = BORDERS[style];
     const bc = borderColor;

package/dist/utils/diff-renderer.js

@@ -320,7 +320,7 @@ function renderSplit(diff, opts) {
     const lang = useSyntax ? detectLanguage(opts.filePath) : undefined;
     const totalWidth = opts.width;
     // 3 chars for " │ " separator
-    const colWidth = Math.floor((totalWidth - 3) / 2);
+    const colWidth = Math.max(1, Math.floor((totalWidth - 3) / 2));
     // Compute max line number width
     let maxNo = 0;
     for (const hunk of diff.hunks) {

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

@@ -0,0 +1,26 @@
+/**
+ * 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

@@ -0,0 +1,76 @@
+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/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/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);
+    }
+}