agent-sh 0.1.0

package/dist/utils/file-watcher.js

@@ -0,0 +1,101 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+const SKIP_DIRS = new Set([
+    ".git", "node_modules", "dist", "build", ".next",
+    "__pycache__", ".venv", "vendor", ".cache", ".turbo",
+]);
+const MAX_FILES = 200;
+const MAX_FILE_SIZE = 100_000; // 100 KB
+/**
+ * Snapshots the working directory before an agent prompt so that
+ * file modifications made by **any** method (ACP writeTextFile,
+ * the agent's own edit tools, shell commands, etc.) can be detected
+ * and shown as an interactive diff preview.
+ */
+export class FileWatcher {
+    cwd;
+    baseline = new Map();
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    /**
+     * Recursively snapshot all text files in the working directory.
+     * Skips common non-source directories, binary files, and files
+     * exceeding MAX_FILE_SIZE.  Capped at MAX_FILES entries.
+     */
+    async snapshot() {
+        this.baseline.clear();
+        let count = 0;
+        const walk = async (dir) => {
+            if (count >= MAX_FILES)
+                return;
+            let entries;
+            try {
+                entries = await fs.readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (count >= MAX_FILES)
+                    return;
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (!SKIP_DIRS.has(entry.name))
+                        await walk(full);
+                }
+                else if (entry.isFile()) {
+                    try {
+                        const stat = await fs.stat(full);
+                        if (stat.size > MAX_FILE_SIZE || stat.size === 0)
+                            continue;
+                        const content = await fs.readFile(full, "utf-8");
+                        this.baseline.set(full, content);
+                        count++;
+                    }
+                    catch {
+                        // Skip binary / unreadable files
+                    }
+                }
+            }
+        };
+        await walk(this.cwd);
+    }
+    /** Update baseline after a write is approved (avoids double-reporting). */
+    approve(absPath, content) {
+        this.baseline.set(absPath, content);
+    }
+    /** Detect all tracked files whose on-disk content differs from baseline. */
+    async detectChanges() {
+        const changes = [];
+        for (const [absPath, baseline] of this.baseline) {
+            let after;
+            try {
+                after = await fs.readFile(absPath, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            if (baseline !== after) {
+                changes.push({
+                    path: absPath,
+                    relPath: path.relative(this.cwd, absPath),
+                    before: baseline,
+                    after,
+                });
+            }
+        }
+        return changes;
+    }
+    /** Revert a file to its baseline content. */
+    async revert(absPath) {
+        const baseline = this.baseline.get(absPath);
+        if (baseline !== undefined) {
+            await fs.writeFile(absPath, baseline, "utf-8");
+        }
+    }
+    /** Clear all tracking state. */
+    reset() {
+        this.baseline.clear();
+    }
+}

package/dist/utils/markdown.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
+ * Returns an array of lines, each fitting within `maxWidth` visible characters.
+ */
+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.
+ */
+export declare class MarkdownRenderer {
+    private buffer;
+    private inCodeBlock;
+    private codeLanguage;
+    private codeLines;
+    private contentWidth;
+    private firstLine;
+    constructor(terminalWidth?: number);
+    /**
+     * Push a streaming chunk. Complete lines are rendered immediately;
+     * incomplete trailing text stays in the buffer.
+     */
+    push(chunk: string): void;
+    /**
+     * Flush any remaining text in the buffer (called when the response ends).
+     */
+    flush(): void;
+    printTopBorder(): void;
+    printBottomBorder(): void;
+    private processBuffer;
+    private processLine;
+    private renderLine;
+    private renderInline;
+    private renderCodeBlock;
+    /**
+     * Write a single line with a subtle left indent.
+     */
+    writeLine(text: string): void;
+}

package/dist/utils/markdown.js

@@ -0,0 +1,248 @@
+import { highlight } from "cli-highlight";
+import { visibleLen } from "./ansi.js";
+import { palette as p } from "./palette.js";
+const MAX_CONTENT_WIDTH = 90;
+/**
+ * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
+ * Returns an array of lines, each fitting within `maxWidth` visible characters.
+ */
+export function wrapLine(text, maxWidth) {
+    if (visibleLen(text) <= maxWidth)
+        return [text];
+    const result = [];
+    // Split into segments: ANSI codes and visible text
+    const segments = text.match(/(\x1b\[[^m]*m|[^\x1b]+)/g) || [text];
+    let currentLine = "";
+    let currentWidth = 0;
+    let activeStyles = ""; // track ANSI styles to reapply after wraps
+    for (const seg of segments) {
+        if (seg.startsWith("\x1b[")) {
+            // ANSI code — track it, add to current line
+            currentLine += seg;
+            if (seg === p.reset) {
+                activeStyles = "";
+            }
+            else {
+                activeStyles += seg;
+            }
+            continue;
+        }
+        // Visible text — split into words
+        const words = seg.split(/( +)/);
+        for (const word of words) {
+            if (word.length === 0)
+                continue;
+            if (currentWidth + word.length <= maxWidth) {
+                currentLine += word;
+                currentWidth += word.length;
+            }
+            else if (currentWidth === 0) {
+                // Single word longer than maxWidth — hard break
+                let remaining = word;
+                while (remaining.length > 0) {
+                    const chunk = remaining.slice(0, maxWidth - currentWidth || maxWidth);
+                    remaining = remaining.slice(chunk.length);
+                    currentLine += chunk;
+                    if (remaining.length > 0) {
+                        result.push(currentLine + p.reset);
+                        currentLine = activeStyles;
+                        currentWidth = 0;
+                    }
+                    else {
+                        currentWidth += chunk.length;
+                    }
+                }
+            }
+            else {
+                // Wrap to next line
+                result.push(currentLine + p.reset);
+                currentLine = activeStyles;
+                currentWidth = 0;
+                // Skip leading spaces on new line
+                const trimmed = word.replace(/^ +/, "");
+                currentLine += trimmed;
+                currentWidth = trimmed.length;
+            }
+        }
+    }
+    if (currentLine.length > 0) {
+        result.push(currentLine);
+    }
+    return result;
+}
+/**
+ * Streaming markdown renderer that processes chunks of text,
+ * renders complete lines with ANSI formatting, and wraps output
+ * in a bordered box.
+ */
+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);
+    }
+    /**
+     * Push a streaming chunk. Complete lines are rendered immediately;
+     * incomplete trailing text stays in the buffer.
+     */
+    push(chunk) {
+        this.buffer += chunk;
+        this.processBuffer();
+    }
+    /**
+     * 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 = "";
+        }
+    }
+    printTopBorder() {
+        const w = Math.min(this.contentWidth, 40);
+        process.stdout.write(`${p.dim}${p.accent}${"─".repeat(w)}${p.reset}\n`);
+        this.firstLine = true;
+    }
+    printBottomBorder() {
+        const w = Math.min(this.contentWidth, 40);
+        process.stdout.write(`${p.dim}${p.accent}${"─".repeat(w)}${p.reset}\n`);
+    }
+    processBuffer() {
+        const lines = this.buffer.split("\n");
+        this.buffer = lines.pop();
+        for (const line of lines) {
+            this.processLine(line);
+        }
+    }
+    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 = [];
+                return;
+            }
+            else {
+                this.inCodeBlock = false;
+                this.renderCodeBlock();
+                return;
+            }
+        }
+        if (this.inCodeBlock) {
+            this.codeLines.push(line);
+            return;
+        }
+        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);
+        }
+    }
+    renderLine(line) {
+        if (line.trim() === "")
+            return "";
+        // Headings
+        const h1 = line.match(/^# (.+)/);
+        if (h1)
+            return `${p.bold}${p.warning}${h1[1]}${p.reset}`;
+        const h2 = line.match(/^## (.+)/);
+        if (h2)
+            return `${p.bold}${p.accent}${h2[1]}${p.reset}`;
+        const h3 = line.match(/^### (.+)/);
+        if (h3)
+            return `${p.bold}${h3[1]}${p.reset}`;
+        const h4 = line.match(/^#{4,} (.+)/);
+        if (h4)
+            return `${p.bold}${h4[1]}${p.reset}`;
+        // Horizontal rule
+        if (/^(-{3,}|_{3,}|\*{3,})\s*$/.test(line)) {
+            return `${p.muted}${"─".repeat(this.contentWidth)}${p.reset}`;
+        }
+        // Blockquote
+        const bq = line.match(/^>\s?(.*)/);
+        if (bq)
+            return `${p.muted}│${p.reset} ${p.dim}${p.italic}${this.renderInline(bq[1] || "")}${p.reset}`;
+        // Unordered list
+        const ul = line.match(/^(\s*)[*\-+]\s+(.*)/);
+        if (ul) {
+            const indent = ul[1] || "";
+            return `${indent}  ${p.accent}*${p.reset} ${this.renderInline(ul[2] || "")}`;
+        }
+        // Ordered list
+        const ol = line.match(/^(\s*)(\d+)[.)]\s+(.*)/);
+        if (ol) {
+            const indent = ol[1] || "";
+            return `${indent}  ${p.accent}${ol[2]}.${p.reset} ${this.renderInline(ol[3] || "")}`;
+        }
+        return this.renderInline(line);
+    }
+    renderInline(text) {
+        // Inline code
+        text = text.replace(/`([^`]+)`/g, `${p.accent}$1${p.reset}`);
+        // Bold + italic
+        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}`);
+        // Italic
+        text = text.replace(/\*(.+?)\*/g, `${p.italic}$1${p.reset}`);
+        text = text.replace(/_(.+?)_/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.
+     */
+    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) {
+            }
+        }
+    }
+}

package/dist/utils/palette.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Semantic color palette with a small set of base roles.
+ *
+ * Components use these roles instead of raw ANSI escapes.
+ * Extensions can override via setPalette() for theming.
+ *
+ * Design: ~10 base slots that cover all UI needs. Components
+ * derive specific uses from these (e.g. "diff added" = success,
+ * "tool title" = warning, "user query border" = accent).
+ */
+export interface ColorPalette {
+    accent: string;
+    success: string;
+    warning: string;
+    error: string;
+    muted: string;
+    successBg: string;
+    errorBg: string;
+    successBgEmph: string;
+    errorBgEmph: string;
+    bold: string;
+    dim: string;
+    italic: string;
+    underline: string;
+    reset: string;
+}
+/** Active palette — import and use directly in components. */
+export declare const palette: ColorPalette;
+/** Override palette slots. Merges with current values. */
+export declare function setPalette(overrides: Partial<ColorPalette>): void;
+/** Reset palette to defaults. */
+export declare function resetPalette(): void;

package/dist/utils/palette.js

@@ -0,0 +1,36 @@
+/**
+ * Semantic color palette with a small set of base roles.
+ *
+ * Components use these roles instead of raw ANSI escapes.
+ * Extensions can override via setPalette() for theming.
+ *
+ * Design: ~10 base slots that cover all UI needs. Components
+ * derive specific uses from these (e.g. "diff added" = success,
+ * "tool title" = warning, "user query border" = accent).
+ */
+const defaultPalette = {
+    accent: "\x1b[36m", // cyan
+    success: "\x1b[32m", // green
+    warning: "\x1b[33m", // yellow
+    error: "\x1b[31m", // red
+    muted: "\x1b[90m", // gray
+    successBg: "\x1b[48;2;0;60;0m",
+    errorBg: "\x1b[48;2;50;0;0m",
+    successBgEmph: "\x1b[48;2;0;112;0m",
+    errorBgEmph: "\x1b[48;2;90;0;0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    italic: "\x1b[3m",
+    underline: "\x1b[4m",
+    reset: "\x1b[0m",
+};
+/** Active palette — import and use directly in components. */
+export const palette = { ...defaultPalette };
+/** Override palette slots. Merges with current values. */
+export function setPalette(overrides) {
+    Object.assign(palette, overrides);
+}
+/** Reset palette to defaults. */
+export function resetPalette() {
+    Object.assign(palette, defaultPalette);
+}

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

@@ -0,0 +1,33 @@
+export type ToolDisplayMode = "full" | "compact" | "summary";
+export interface ToolCallRender {
+    /** The tool title (e.g. "Read file", "Bash command"). */
+    title: string;
+    /** Optional command string for bash-like tools. */
+    command?: string;
+}
+export interface ToolResultRender {
+    exitCode: number | null;
+    /** Output lines from the tool. */
+    outputLines?: string[];
+    /** Maximum output lines to show. Default 10. */
+    maxOutputLines?: number;
+}
+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 renderToolResult(result: ToolResultRender, width: number): string[];
+export declare function formatElapsed(ms: number): string;
+export interface SpinnerState {
+    frame: number;
+    startTime: number;
+    interval: ReturnType<typeof setInterval> | null;
+}
+export declare function createSpinner(): SpinnerState;
+/**
+ * Start a spinner that writes to stdout on the current line.
+ * Returns the SpinnerState for later stopping.
+ */
+export declare function startSpinner(label: string, opts?: {
+    color?: string;
+}): SpinnerState;
+export declare function stopSpinner(state: SpinnerState): void;

package/dist/utils/tool-display.js

@@ -0,0 +1,141 @@
+/**
+ * Tool display renderer with elapsed timer and width-adaptive output.
+ *
+ * Follows the render(width) -> string[] protocol for completed tools.
+ * Also provides a spinner/timer component for in-progress tools.
+ */
+import { visibleLen } from "./ansi.js";
+import { palette as p } from "./palette.js";
+// ── Quiet command detection ──────────────────────────────────────
+const QUIET_PATTERNS = [
+    /^cd\b/,
+    /^mkdir\b/,
+    /^touch\b/,
+    /^rm\b/,
+    /^cp\b/,
+    /^mv\b/,
+    /^ln\b/,
+    /^chmod\b/,
+    /^chown\b/,
+    /^git\s+(add|checkout|branch|switch|stash|tag|config)\b/,
+    /^npm\s+(install|ci|uninstall)\b/,
+    /^yarn\s+(add|remove|install)\b/,
+    /^pnpm\s+(add|remove|install)\b/,
+    /^export\b/,
+    /^source\b/,
+    /^\.\s/,
+];
+export function isQuietCommand(command) {
+    const trimmed = command.trim();
+    return QUIET_PATTERNS.some((p) => p.test(trimmed));
+}
+// ── Mode selection ───────────────────────────────────────────────
+export function selectToolDisplayMode(width) {
+    if (width >= 80)
+        return "full";
+    if (width >= 40)
+        return "compact";
+    return "summary";
+}
+// ── Tool call rendering ──────────────────────────────────────────
+export function renderToolCall(tool, width) {
+    const mode = selectToolDisplayMode(width);
+    if (mode === "summary") {
+        const text = truncateVisible(`▶ ${tool.title}`, width);
+        return [`${p.warning}${text}${p.reset}`];
+    }
+    const lines = [];
+    lines.push(`${p.warning}${p.bold}▶ ${tool.title}${p.reset}`);
+    if (tool.command && mode === "full") {
+        const maxCmdW = Math.max(1, width - 4);
+        const cmd = tool.command.length > maxCmdW
+            ? tool.command.slice(0, maxCmdW - 1) + "…"
+            : tool.command;
+        lines.push(`  ${p.dim}$ ${cmd}${p.reset}`);
+    }
+    return lines;
+}
+// ── Tool result rendering ────────────────────────────────────────
+export function renderToolResult(result, width) {
+    const mode = selectToolDisplayMode(width);
+    const lines = [];
+    // Status indicator
+    if (result.exitCode === null) {
+        lines.push(`  ${p.muted}(timed out)${p.reset}`);
+    }
+    else if (result.exitCode === 0) {
+        lines.push(`  ${p.success}✓${p.reset}`);
+    }
+    else {
+        lines.push(`  ${p.error}✗ exit ${result.exitCode}${p.reset}`);
+    }
+    // Output preview (full mode only)
+    if (mode === "full" && result.outputLines && result.outputLines.length > 0) {
+        const maxLines = result.maxOutputLines ?? 10;
+        const total = result.outputLines.length;
+        const shown = result.outputLines.slice(0, maxLines);
+        const maxTextW = Math.max(1, width - 6);
+        for (const line of shown) {
+            const text = line.length > maxTextW
+                ? line.slice(0, maxTextW - 1) + "…"
+                : line;
+            lines.push(`  ${p.dim}  ${text}${p.reset}`);
+        }
+        if (total > maxLines) {
+            lines.push(`  ${p.dim}  … ${total - maxLines} more lines${p.reset}`);
+        }
+    }
+    return lines;
+}
+// ── Elapsed timer ────────────────────────────────────────────────
+export function formatElapsed(ms) {
+    if (ms < 1000)
+        return "";
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    const rs = s % 60;
+    if (m < 60)
+        return rs > 0 ? `${m}m ${rs}s` : `${m}m`;
+    const h = Math.floor(m / 60);
+    const rm = m % 60;
+    return rm > 0 ? `${h}h ${rm}m` : `${h}h`;
+}
+// ── Spinner with elapsed timer ───────────────────────────────────
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export function createSpinner() {
+    return { frame: 0, startTime: Date.now(), interval: null };
+}
+/**
+ * Start a spinner that writes to stdout on the current line.
+ * Returns the SpinnerState for later stopping.
+ */
+export function startSpinner(label, opts) {
+    const state = createSpinner();
+    const color = opts?.color ?? p.accent;
+    state.interval = setInterval(() => {
+        const frame = SPINNER_FRAMES[state.frame % SPINNER_FRAMES.length];
+        const elapsed = formatElapsed(Date.now() - state.startTime);
+        const timer = elapsed ? ` ${p.dim}${elapsed}${p.reset}` : "";
+        process.stdout.write(`\r  ${color}${frame} ${label}...${p.reset}${timer}\x1b[K`);
+        state.frame++;
+    }, 80);
+    return state;
+}
+export function stopSpinner(state) {
+    if (state.interval) {
+        clearInterval(state.interval);
+        state.interval = null;
+        process.stdout.write("\r\x1b[2K");
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────
+function truncateVisible(text, maxWidth) {
+    if (visibleLen(text) <= maxWidth)
+        return text;
+    // Simple truncation for plain text (no ANSI)
+    if (maxWidth <= 1)
+        return "…";
+    return text.slice(0, maxWidth - 1) + "…";
+}