@vietor/easy-agent 0.2.1 → 0.4.1

package/dist/tools/file_read.js

@@ -1,18 +0,0 @@
-import { readFile } from "node:fs/promises";
-const DESCRIPTION = [
-    "Read a file's full contents as UTF-8 text.",
-    "path may be relative (to the working directory) or absolute.",
-].join(" ");
-export const fileReadTool = {
-    name: "FileRead",
-    description: DESCRIPTION,
-    parameters: {
-        type: "object",
-        properties: { path: { type: "string" } },
-        required: ["path"],
-    },
-    async execute(args) {
-        return readFile(args.path, "utf-8");
-    },
-    summaryArg: "path",
-};

package/dist/tools/file_write.js

@@ -1,22 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-const DESCRIPTION = [
-    "Write content to a file, overwriting it entirely if it exists and creating parent directories as needed.",
-    "Use for new files or full rewrites; for targeted changes prefer FileEdit.",
-].join(" ");
-export const fileWriteTool = {
-    name: "FileWrite",
-    description: DESCRIPTION,
-    parameters: {
-        type: "object",
-        properties: { path: { type: "string" }, content: { type: "string" } },
-        required: ["path", "content"],
-    },
-    async execute(args) {
-        const path = args.path;
-        await mkdir(dirname(path), { recursive: true });
-        await writeFile(path, args.content, "utf-8");
-        return `Wrote ${path}`;
-    },
-    summaryArg: "path",
-};

package/dist/tools/glob.js

@@ -1,29 +0,0 @@
-import { resolveCwd, runRgLines } from "../util/ripgrep.js";
-const DESCRIPTION = [
-    "List files under a directory, optionally filtered by a glob pattern (e.g. **/*.ts); omit pattern to list every file.",
-    "Skips node_modules and .git.",
-    "Returns paths relative to the root, one per line.",
-].join(" ");
-export const globTool = {
-    name: "Glob",
-    description: DESCRIPTION,
-    parameters: {
-        type: "object",
-        properties: {
-            pattern: { type: "string", description: "glob pattern; omit to list all files" },
-            path: { type: "string", description: "root directory, defaults to cwd" },
-        },
-        required: [],
-    },
-    async execute(args) {
-        const cwd = resolveCwd(args.path);
-        const rgArgs = ["--files"];
-        const pattern = args.pattern;
-        if (pattern)
-            rgArgs.push("-g", pattern);
-        rgArgs.push(".");
-        const files = await runRgLines(rgArgs, cwd);
-        return files.length ? files.join("\n") : "(no matches)";
-    },
-    summaryArg: ["pattern", "path"],
-};

package/dist/tools/grep.js

@@ -1,36 +0,0 @@
-import { resolveCwd, runRgLines } from "../util/ripgrep.js";
-const MAX_MATCHES = 200;
-const DESCRIPTION = [
-    "Search file contents under a directory recursively for a regex pattern (RE2 syntax).",
-    "Skips node_modules and .git.",
-    "Returns matching lines as path:line: content, capped at 200 matches.",
-].join(" ");
-export const grepTool = {
-    name: "Grep",
-    description: DESCRIPTION,
-    parameters: {
-        type: "object",
-        properties: {
-            pattern: { type: "string" },
-            path: { type: "string", description: "root directory, defaults to cwd" },
-        },
-        required: ["pattern"],
-    },
-    async execute(args) {
-        const cwd = resolveCwd(args.path);
-        const rgArgs = [
-            "--line-number",
-            "--with-filename",
-            "--no-heading",
-            args.pattern,
-            ".",
-        ];
-        const lines = await runRgLines(rgArgs, cwd);
-        if (!lines.length)
-            return "(no matches)";
-        if (lines.length > MAX_MATCHES)
-            return lines.slice(0, MAX_MATCHES).join("\n") + "\n(truncated)";
-        return lines.join("\n");
-    },
-    summaryArg: ["pattern", "path"],
-};

package/dist/tools/registry.js

@@ -1,51 +0,0 @@
-import { shellTool } from "./shell.js";
-import { fileReadTool } from "./file_read.js";
-import { fileWriteTool } from "./file_write.js";
-import { fileEditTool } from "./file_edit.js";
-import { globTool } from "./glob.js";
-import { grepTool } from "./grep.js";
-import { webFetchTool } from "./web_fetch.js";
-export class ToolRegistry {
-    tools = new Map();
-    register(tool) {
-        this.tools.set(tool.name, tool);
-    }
-    schemas() {
-        return [...this.tools.values()].map((t) => ({
-            type: "function",
-            function: {
-                name: t.name,
-                description: t.description,
-                parameters: t.parameters,
-            },
-        }));
-    }
-    async execute(name, args) {
-        const tool = this.tools.get(name);
-        if (!tool)
-            return { content: `Error: unknown tool ${name}`, isError: true };
-        try {
-            const r = await tool.execute(args);
-            return typeof r === "string" ? { content: r } : r;
-        }
-        catch (e) {
-            return { content: `Error: ${e.message}`, isError: true };
-        }
-    }
-    summarize(name, args) {
-        const tool = this.tools.get(name);
-        if (!tool?.summaryArg)
-            return "";
-        const keys = Array.isArray(tool.summaryArg) ? tool.summaryArg : [tool.summaryArg];
-        for (const k of keys) {
-            const v = args[k];
-            if (typeof v === "string" && v)
-                return v;
-        }
-        return "";
-    }
-}
-export function registerBuiltinTools(tools) {
-    for (const t of [shellTool, fileReadTool, fileWriteTool, fileEditTool, globTool, grepTool, webFetchTool])
-        tools.register(t);
-}

package/dist/tools/shell.js

@@ -1,34 +0,0 @@
-import { runProcess } from "../util/process.js";
-const isWindows = process.platform === "win32";
-const shell = isWindows ? "powershell.exe" : "/bin/sh";
-const shellArgs = isWindows ? ["-NoProfile", "-NonInteractive", "-Command"] : ["-c"];
-const commandPrefix = isWindows
-    ? "[Console]::OutputEncoding=[Text.Encoding]::UTF8; $OutputEncoding=[Text.Encoding]::UTF8; "
-    : "";
-const DESCRIPTION = [
-    "Execute a shell command and return combined stdout and stderr.",
-    isWindows
-        ? "Runs on Windows PowerShell 5.1 (powershell.exe), NOT pwsh (PowerShell 7+). Chain commands with semicolons; conditional command chaining, null-coalescing, and ternary operators are pwsh-only and unsupported here."
-        : `Runs on ${shell} (POSIX sh).`,
-    "Runs synchronously with no stdin, so interactive prompts cannot be answered.",
-    "Output is capped at ~10MB; for large files prefer Grep or FileRead.",
-    "For URL content prefer WebFetch; use Shell for web requests only when WebFetch cannot (non-GET, custom headers, auth, raw bytes, or status codes).",
-].join(" ");
-export const shellTool = {
-    name: "Shell",
-    description: DESCRIPTION,
-    parameters: {
-        type: "object",
-        properties: { command: { type: "string" } },
-        required: ["command"],
-    },
-    async execute(args) {
-        const command = args.command;
-        const r = await runProcess(shell, [...shellArgs, commandPrefix + command]);
-        if (r.status === 0 && !r.error) {
-            return r.stdout || "(no output)";
-        }
-        return (r.stdout || "") + (r.stderr || "") + (r.error?.message || "");
-    },
-    summaryArg: "command",
-};

package/dist/tools/types.js

@@ -1 +0,0 @@
-export {};

package/dist/tools/web_fetch.js

@@ -1,140 +0,0 @@
-import { Parser } from "htmlparser2";
-import TurndownService from "turndown";
-const SKIP_TAGS = new Set(["script", "style", "noscript", "template", "head", "title", "meta", "link", "base"]);
-const BLOCK_TAGS = new Set([
-    "p",
-    "div",
-    "ul",
-    "ol",
-    "li",
-    "br",
-    "tr",
-    "table",
-    "blockquote",
-    "pre",
-    "section",
-    "article",
-    "header",
-    "footer",
-    "nav",
-    "aside",
-    "h1",
-    "h2",
-    "h3",
-    "h4",
-    "h5",
-    "h6",
-    "hr",
-]);
-function normalize(s) {
-    return s
-        .replace(/\r\n/g, "\n")
-        .replace(/\u00a0/g, " ")
-        .replace(/[ \t]+\n/g, "\n")
-        .split("\n")
-        .map((l) => l.replace(/[ \t]{2,}/g, " ").replace(/\s+$/, ""))
-        .join("\n")
-        .replace(/\n{3,}/g, "\n\n")
-        .trim();
-}
-function htmlToText(html) {
-    let out = "";
-    let skip = 0;
-    const parser = new Parser({
-        onopentag(name) {
-            if (SKIP_TAGS.has(name))
-                skip++;
-            else if (name === "li")
-                out += "\n- ";
-            else if (BLOCK_TAGS.has(name))
-                out += "\n";
-        },
-        onclosetag(name) {
-            if (SKIP_TAGS.has(name) && skip > 0)
-                skip--;
-        },
-        ontext(text) {
-            if (skip === 0)
-                out += text;
-        },
-    });
-    parser.write(html);
-    parser.end();
-    return normalize(out);
-}
-const turndown = new TurndownService({
-    headingStyle: "atx",
-    hr: "---",
-    bulletListMarker: "-",
-    codeBlockStyle: "fenced",
-    emDelimiter: "*",
-    strongDelimiter: "**",
-    linkStyle: "inlined",
-});
-turndown.remove(["script", "style", "title", "meta", "head", "noscript", "template", "link", "base"]);
-function htmlToMarkdown(html) {
-    return turndown.turndown(html);
-}
-function mimeFrom(contentType) {
-    return contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
-}
-function isTextualMime(mime) {
-    return (!mime ||
-        mime.startsWith("text/") ||
-        mime === "application/json" ||
-        mime.endsWith("+json") ||
-        mime === "application/xml" ||
-        mime.endsWith("+xml") ||
-        mime === "application/javascript" ||
-        mime === "application/x-javascript");
-}
-const DESCRIPTION = [
-    "Fetch a URL via GET and return its content as markdown (default) or plain text.",
-    "Follows redirects.",
-    "HTML is converted; other textual types (JSON, XML, plain text) are returned raw; non-textual content (images, binaries) is rejected.",
-].join(" ");
-export const webFetchTool = {
-    name: "WebFetch",
-    description: DESCRIPTION,
-    parameters: {
-        type: "object",
-        properties: {
-            url: {
-                type: "string",
-                description: "full URL including scheme (http or https)",
-            },
-            format: {
-                type: "string",
-                description: "output format: 'markdown' (default) or 'text'",
-            },
-        },
-        required: ["url"],
-    },
-    async execute(args) {
-        const url = args.url;
-        const format = (args.format || "markdown").toLowerCase();
-        let res;
-        try {
-            res = await fetch(url, {
-                headers: {
-                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
-                },
-                redirect: "follow",
-            });
-        }
-        catch (e) {
-            throw new Error(`failed to fetch ${url}: ${e.message}`);
-        }
-        if (!res.ok)
-            throw new Error(`${res.status} ${res.statusText} for ${url}`);
-        const body = await res.text();
-        const contentType = res.headers.get("content-type") || "";
-        const mime = mimeFrom(contentType);
-        if (!isTextualMime(mime))
-            throw new Error(`unsupported content type: ${mime} for ${url}`);
-        if (!contentType.includes("html"))
-            return body;
-        return format === "text" ? htmlToText(body) : htmlToMarkdown(body);
-    },
-    summaryArg: "url",
-};

package/dist/tui/LogStore.js

@@ -1,35 +0,0 @@
-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/util/async.js

@@ -1,58 +0,0 @@
-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/fs.js

@@ -1,17 +0,0 @@
-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

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

@@ -1,33 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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(/^\.\//, ""));
-}