@vietor/easy-agent 0.1.1

package/dist/tui/LogStore.js

@@ -0,0 +1,35 @@
+export class LogStore {
+    entries = [];
+    listeners = new Set();
+    getSnapshot = () => this.entries;
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    };
+    append(entry) {
+        this.entries = [...this.entries, entry];
+        this.emit();
+    }
+    clear() {
+        this.entries = [];
+        this.emit();
+    }
+    setToolResult(id, result, isError) {
+        for (let i = this.entries.length - 1; i >= 0; i--) {
+            const entry = this.entries[i];
+            if (entry.kind === "tool" && entry.id === id && entry.result === null) {
+                const copy = [...this.entries];
+                copy[i] = { ...entry, result, isError };
+                this.entries = copy;
+                this.emit();
+                return;
+            }
+        }
+    }
+    emit() {
+        for (const listener of this.listeners)
+            listener();
+    }
+}

package/dist/tui/LogView.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from "react";
+import { Box, Text } from "ink";
+import { Markdown } from "./components/Markdown.js";
+function preview(isError, text) {
+    if (isError) {
+        const previewText = text.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+        return previewText.length > 100 ? previewText.slice(0, 100) + "…" : previewText;
+    }
+    const lineCount = text.length === 0 ? 0 : (text.match(/\n/g) || []).length + 1;
+    const byteCount = Buffer.byteLength(text, "utf-8");
+    return `Result: ${byteCount} bytes, ${lineCount} lines`;
+}
+export const LogView = memo(function Entry({ entry }) {
+    switch (entry.kind) {
+        case "user":
+            return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { children: `❯ ${entry.text}` }) }));
+        case "skill":
+            return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "magenta", children: `◈ skill: ${entry.name}` }) }));
+        case "assistant":
+            return (_jsx(Box, { marginTop: 1, children: _jsx(Markdown, { color: "green", children: entry.text }) }));
+        case "tool":
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: `● ${entry.name}${entry.summary ? ` ${entry.summary}` : ""}` }), entry.result !== null ? (_jsx(Text, { color: entry.isError ? "red" : "gray", children: `  ${preview(entry.isError ?? false, entry.result)}` })) : null] }));
+        case "retry":
+            return (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: `↻ Retry ${entry.attempt}/${entry.max}` }) }));
+        case "error":
+            return (_jsx(Box, { children: _jsx(Text, { color: "red", children: `✗ ${entry.text}` }) }));
+        case "interrupted":
+            return (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "\u25FC interrupted" }) }));
+        case "system":
+            return (_jsx(Box, { children: _jsx(Text, { color: "gray", children: entry.text }) }));
+    }
+});

package/dist/tui/PromptOrCommandInput.js

@@ -0,0 +1,61 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+const MAX_ITEMS = 4;
+export function PromptOrCommandInput({ commands, onCommand, onPrompt }) {
+    const [input, setInput] = useState("");
+    const showMenu = input.startsWith("/");
+    const prefix = showMenu ? input.slice(1) : "";
+    const filtered = useMemo(() => {
+        if (!showMenu)
+            return [];
+        if (prefix === "")
+            return commands;
+        return commands.filter((c) => c.name.startsWith(prefix));
+    }, [showMenu, prefix, commands]);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    useEffect(() => {
+        if (filtered.length > 0 && selectedIndex === -1)
+            setSelectedIndex(0);
+        else if (selectedIndex >= filtered.length)
+            setSelectedIndex(Math.max(0, filtered.length - 1));
+    }, [filtered.length]);
+    useInput((_input, key) => {
+        if (key.upArrow) {
+            setSelectedIndex((i) => (i <= 0 ? filtered.length - 1 : i - 1));
+        }
+        else if (key.downArrow) {
+            setSelectedIndex((i) => (i >= filtered.length - 1 ? 0 : i + 1));
+        }
+        else if (key.escape) {
+            setInput("");
+        }
+    }, { isActive: showMenu });
+    const onSubmit = (value) => {
+        const text = value.trim();
+        setInput("");
+        if (!text)
+            return;
+        if (text.startsWith("/")) {
+            if (filtered.length > 0) {
+                const cmd = filtered[selectedIndex];
+                onCommand(cmd ? cmd.name : prefix);
+            }
+            return;
+        }
+        onPrompt(text);
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [showMenu && filtered.length > 0 ? (_jsx(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", children: (() => {
+                    const total = filtered.length;
+                    const half = Math.floor(MAX_ITEMS / 2);
+                    let start = Math.max(0, selectedIndex - half);
+                    if (start + MAX_ITEMS > total)
+                        start = Math.max(0, total - MAX_ITEMS);
+                    const visible = filtered.slice(start, start + MAX_ITEMS);
+                    return visible.map((cmd, i) => {
+                        const realIdx = start + i;
+                        return (_jsxs(Box, { children: [_jsxs(Text, { color: realIdx === selectedIndex ? "cyan" : undefined, children: [realIdx === selectedIndex ? "▸ " : "  ", "/", cmd.name] }), _jsxs(Text, { dimColor: true, children: ["  ", cmd.description] })] }, cmd.name));
+                    });
+                })() })) : null, _jsxs(Box, { borderStyle: "single", borderLeft: false, borderRight: false, borderColor: "gray", children: [_jsx(Text, { color: "gray", children: "\u276F " }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: onSubmit })] })] }));
+}

package/dist/tui/Spinner.js

@@ -0,0 +1,13 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text } from "ink";
+import { timeDisplay, compactDisplay } from "../util/format.js";
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export function Spinner({ label, elapsed, promptTokens, completionTokens, }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const id = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), 80);
+        return () => clearInterval(id);
+    }, []);
+    return (_jsxs(Text, { color: "gray", children: [SPINNER_FRAMES[frame], " ", label, " \u00B7 ", timeDisplay(elapsed), " \u00B7 \u2191", compactDisplay(promptTokens), " \u00B7 \u2193", compactDisplay(completionTokens)] }));
+}

package/dist/tui/components/Markdown.js

@@ -0,0 +1,210 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment, useMemo } from "react";
+import { Box, Text } from "ink";
+import { lexer } from "marked";
+import stringWidth from "string-width";
+const HEADING_COLOR = ["magentaBright", "cyanBright", "blue", "yellow", "green", "gray"];
+export function Markdown({ children, color }) {
+    const tokens = useMemo(() => lexer(children, { gfm: true }), [children]);
+    return _jsx(Box, { flexDirection: "column", children: renderBlocks(tokens, color) });
+}
+function renderBlocks(tokens, color) {
+    return tokens.map((token, i) => (_jsx(Fragment, { children: renderBlock(token, color) }, i)));
+}
+function renderBlock(token, color) {
+    switch (token.type) {
+        case "space":
+            return _jsx(Text, { children: " " });
+        case "hr":
+            return (_jsx(Box, { borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, borderColor: "gray" }));
+        case "heading":
+            return (_jsx(Box, { children: _jsx(Text, { bold: true, underline: token.depth === 1, color: HEADING_COLOR[token.depth - 1], children: renderInline(token.tokens) }) }));
+        case "code":
+            return (_jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, flexDirection: "column", children: [token.lang ? _jsx(Text, { dimColor: true, children: token.lang }) : null, _jsx(Text, { children: token.text })] }));
+        case "blockquote":
+            return (_jsx(Box, { borderStyle: "single", borderTop: false, borderBottom: false, borderRight: false, borderColor: "gray", paddingLeft: 1, children: renderBlocks(token.tokens, color) }));
+        case "list":
+            return renderList(token, color);
+        case "table":
+            return renderTable(token, color);
+        case "paragraph":
+            return _jsx(Text, { color: color, children: renderInline(token.tokens) });
+        case "text":
+            return _jsx(Text, { color: color, children: token.tokens ? renderInline(token.tokens) : token.text });
+        case "html":
+            return _jsx(Text, { dimColor: true, children: token.text });
+        default:
+            return null;
+    }
+}
+function renderInline(tokens) {
+    if (!tokens || tokens.length === 0)
+        return null;
+    return tokens.map((token, i) => {
+        const tok = token;
+        switch (tok.type) {
+            case "text":
+                return _jsx(Text, { children: tok.tokens ? renderInline(tok.tokens) : tok.text }, i);
+            case "strong":
+                return _jsx(Text, { bold: true, children: renderInline(tok.tokens) }, i);
+            case "em":
+                return _jsx(Text, { italic: true, children: renderInline(tok.tokens) }, i);
+            case "codespan":
+                return _jsx(Text, { color: "cyan", children: tok.text }, i);
+            case "del":
+                return _jsx(Text, { strikethrough: true, children: renderInline(tok.tokens) }, i);
+            case "link":
+                return _jsx(Text, { color: "blue", underline: true, children: renderInline(tok.tokens) }, i);
+            case "image":
+                return _jsx(Text, { color: "magenta", children: tok.text || tok.href }, i);
+            case "br":
+                return _jsx(Text, { children: "\n" }, i);
+            case "escape":
+                return _jsx(Text, { children: tok.text }, i);
+            case "html":
+                return _jsx(Text, { dimColor: true, children: tok.text }, i);
+            default:
+                return _jsx(Text, { children: tok.text ?? "" }, i);
+        }
+    });
+}
+function renderList(token, color) {
+    const markers = token.items.map((item, i) => {
+        if (item.task)
+            return item.checked ? "[x]" : "[ ]";
+        if (token.ordered)
+            return `${(token.start === "" ? i + 1 : Number(token.start) + i)}.`;
+        return "•";
+    });
+    const markerWidth = Math.max(1, ...markers.map((s) => stringWidth(s)));
+    return (_jsx(Box, { flexDirection: "column", children: token.items.map((item, i) => (_jsxs(Box, { marginTop: token.loose && i > 0 ? 1 : 0, children: [_jsxs(Text, { color: color, children: [padAlign(markers[i], markerWidth, "right"), " "] }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: renderBlocks(item.tokens, color) })] }, i))) }));
+}
+function renderTable(token, color) {
+    const aligns = token.align;
+    const cols = token.header.length;
+    const overhead = 3 * cols + 1;
+    const available = Math.max(1, (process.stdout.columns ?? 80) - 2 - overhead);
+    const natural = new Array(cols).fill(0);
+    for (const row of [token.header, ...token.rows]) {
+        for (let c = 0; c < cols; c++) {
+            const w = stringWidth(tokensToText(row[c].tokens));
+            if (w > natural[c])
+                natural[c] = w;
+        }
+    }
+    const widths = fitWidths(natural, available);
+    const renderRow = (row, bold = false) => {
+        const wrapped = row.map((tc, c) => wrapText(tokensToText(tc.tokens), widths[c]));
+        const height = Math.max(1, ...wrapped.map(lines => lines.length));
+        return Array.from({ length: height }, (_, r) => (_jsx(Text, { children: [
+                ...row.flatMap((_, c) => [
+                    _jsx(Text, { dimColor: true, children: "\u2502" }, `s${c}`),
+                    _jsx(Text, { color: color, bold: bold, children: ` ${padAlign(wrapped[c][r] ?? "", widths[c], aligns[c])} ` }, `c${c}`),
+                ]),
+                _jsx(Text, { dimColor: true, children: "\u2502" }, "e"),
+            ] }, r)));
+    };
+    const border = (l, m, r) => l + widths.map(w => "─".repeat(w + 2)).join(m) + r;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: border("┌", "┬", "┐") }), _jsx(Fragment, { children: renderRow(token.header, true) }), _jsx(Text, { dimColor: true, children: border("├", "┼", "┤") }), token.rows.map((row, i) => (_jsx(Fragment, { children: renderRow(row) }, i))), _jsx(Text, { dimColor: true, children: border("└", "┴", "┘") })] }));
+}
+function tokensToText(tokens) {
+    if (!tokens)
+        return "";
+    return tokens.map(tokenToText).join("");
+}
+function tokenToText(token) {
+    const t = token;
+    switch (t.type) {
+        case "text":
+            return t.tokens ? tokensToText(t.tokens) : t.text;
+        case "strong":
+        case "em":
+        case "del":
+            return tokensToText(t.tokens);
+        case "codespan":
+            return t.text;
+        case "link":
+            return tokensToText(t.tokens);
+        case "image":
+            return t.text || t.href;
+        case "br":
+            return "";
+        case "escape":
+            return t.text;
+        case "html":
+            return t.text;
+        default:
+            return t.text ?? "";
+    }
+}
+function padAlign(text, width, align) {
+    const pad = Math.max(0, width - stringWidth(text));
+    if (align === "right")
+        return " ".repeat(pad) + text;
+    if (align === "center")
+        return " ".repeat(Math.floor(pad / 2)) + text + " ".repeat(Math.ceil(pad / 2));
+    return text + " ".repeat(pad);
+}
+function fitWidths(widths, available) {
+    const fitted = widths.slice();
+    let total = fitted.reduce((a, b) => a + b, 0);
+    if (total <= available)
+        return fitted;
+    while (total > available) {
+        let max = 0;
+        for (let i = 1; i < fitted.length; i++)
+            if (fitted[i] > fitted[max])
+                max = i;
+        if (fitted[max] <= 1)
+            break;
+        fitted[max]--;
+        total--;
+    }
+    return fitted;
+}
+function wrapText(text, width) {
+    if (width <= 0 || stringWidth(text) <= width)
+        return [text];
+    const words = text.split(/\s+/).filter(Boolean);
+    const lines = [];
+    let line = "";
+    let lineW = 0;
+    for (const word of words) {
+        const w = stringWidth(word);
+        if (lineW > 0 && lineW + 1 + w <= width) {
+            line += " " + word;
+            lineW += 1 + w;
+        }
+        else if (w <= width) {
+            if (lineW > 0)
+                lines.push(line);
+            line = word;
+            lineW = w;
+        }
+        else {
+            if (lineW > 0)
+                lines.push(line);
+            line = "";
+            lineW = 0;
+            let cur = "";
+            let curW = 0;
+            for (const ch of word) {
+                const cw = stringWidth(ch);
+                if (cur && curW + cw > width) {
+                    lines.push(cur);
+                    cur = ch;
+                    curW = cw;
+                }
+                else {
+                    cur += ch;
+                    curW += cw;
+                }
+            }
+            line = cur;
+            lineW = curW;
+        }
+    }
+    if (lineW > 0 || lines.length === 0)
+        lines.push(line);
+    return lines;
+}

package/dist/util/async.js

@@ -0,0 +1,58 @@
+export async function withRetry(fn, opts) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (attempt < opts.retries && opts.retryable(e)) {
+                opts.onRetry?.(attempt + 1, opts.retries);
+                await trySleep(opts.backoff(attempt), opts.signal);
+                continue;
+            }
+            throw e;
+        }
+    }
+}
+function trySleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error("aborted"));
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new Error("aborted"));
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+export async function withAbort(fn, opts) {
+    const onAbort = () => opts.onAbort?.();
+    if (opts.signal?.aborted)
+        onAbort();
+    else
+        opts.signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+        return await fn(() => !!opts.signal?.aborted);
+    }
+    finally {
+        opts.signal?.removeEventListener("abort", onAbort);
+    }
+}
+export function withTimeout(p, ms) {
+    let timer;
+    const timed = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms);
+    });
+    return Promise.race([
+        p.finally(() => {
+            if (timer)
+                clearTimeout(timer);
+        }),
+        timed,
+    ]);
+}

package/dist/util/format.js

@@ -0,0 +1,12 @@
+const timeFormatter = new Intl.NumberFormat("en-US", { style: "unit", unit: "second", unitDisplay: "narrow" });
+const compactFormatter = new Intl.NumberFormat("en-US", { notation: "compact", maximumFractionDigits: 2 });
+export function timeDisplay(value) {
+    if (!value)
+        return "0s";
+    return timeFormatter.format(value);
+}
+export function compactDisplay(value) {
+    if (!value)
+        return "0";
+    return compactFormatter.format(value);
+}

package/dist/util/fs.js

@@ -0,0 +1,17 @@
+import { existsSync, readFileSync } from "node:fs";
+export function tryReadFileText(path) {
+    if (existsSync(path)) {
+        const content = readFileSync(path, "utf-8").trim();
+        if (content)
+            return content;
+    }
+    return undefined;
+}
+export function readFirstFileContent(paths, fn) {
+    for (const p of paths) {
+        const content = fn(p);
+        if (content)
+            return content;
+    }
+    return undefined;
+}

package/dist/util/package.js

@@ -0,0 +1,26 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+const __dirname = import.meta.dirname;
+const MAX_PARENT_TRAVERSAL = 10;
+let _pkg = null;
+function findPackageJson() {
+    let current = __dirname;
+    for (let i = 0; i < MAX_PARENT_TRAVERSAL; i++) {
+        const pkgPath = join(current, 'package.json');
+        if (existsSync(pkgPath)) {
+            return pkgPath;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    throw new Error('Cannot find package.json');
+}
+export function getPackageInfo() {
+    if (_pkg === null) {
+        const pkgPath = findPackageJson();
+        _pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    }
+    return _pkg;
+}

package/dist/util/process.js

@@ -0,0 +1,33 @@
+import { spawn } from "node:child_process";
+const MAX_BUFFER = 10 * 1024 * 1024;
+export function runProcess(cmd, args, opts = {}) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, {
+            cwd: opts.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const outChunks = [];
+        const errChunks = [];
+        let size = 0;
+        let overflow = false;
+        child.stdout?.on("data", (c) => {
+            outChunks.push(c);
+            size += c.length;
+            if (size > MAX_BUFFER) {
+                overflow = true;
+                child.kill();
+            }
+        });
+        child.stderr?.on("data", (c) => {
+            errChunks.push(c);
+        });
+        child.on("error", (error) => resolve({ stdout: "", stderr: "", status: null, error }));
+        child.on("close", (status) => {
+            const stdout = Buffer.concat(outChunks).toString("utf-8");
+            const stderr = Buffer.concat(errChunks).toString("utf-8");
+            resolve(overflow
+                ? { stdout, stderr, status, error: new Error("output exceeded maxBuffer") }
+                : { stdout, stderr, status });
+        });
+    });
+}

package/dist/util/ripgrep.js

@@ -0,0 +1,17 @@
+import { isAbsolute, join } from "node:path";
+import { rgPath } from "@vscode/ripgrep";
+import { runProcess } from "./process.js";
+export function resolveCwd(path) {
+    const root = path || ".";
+    return isAbsolute(root) ? root : join(process.cwd(), root);
+}
+export async function runRgLines(args, cwd) {
+    const rgArgs = ["--hidden", "--path-separator", "/", "-g", "!.git/**", ...args];
+    const r = await runProcess(rgPath, rgArgs, { cwd });
+    if (r.error)
+        throw r.error;
+    if (r.status !== 0 && r.status !== 1) {
+        throw new Error((r.stderr || "").trim() || `ripgrep exited with ${r.status}`);
+    }
+    return r.stdout.split("\n").filter(Boolean).map((f) => f.replace(/^\.\//, ""));
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@vietor/easy-agent",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "dist/cli.js",
+  "bin": {
+    "easy-agent": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "tsc && node dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "prepublishOnly": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.30.3",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@vscode/ripgrep": "^1.18.0",
+    "htmlparser2": "^12.0.0",
+    "ink": "^7.1.0",
+    "ink-text-input": "^6.0.0",
+    "marked": "^18.0.5",
+    "openai": "^4.67.0",
+    "react": "^19.2.7",
+    "string-width": "^8.2.1",
+    "turndown": "^7.2.4",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.2.17",
+    "@types/turndown": "^5.0.6",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}