@vietor/easy-agent 0.3.1 → 0.4.1

package/dist/tools/file_edit.js

@@ -1,47 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-const DESCRIPTION = [
-    "Replace occurrences of old_string with new_string in a file.",
-    "old_string must match exactly (including whitespace and indentation); read the file first and include enough surrounding context to be unique.",
-    "By default old_string must appear exactly once; set replace_all to true to replace every occurrence.",
-    "When copying old_string from FileRead output, strip the leading line-number prefix (digits and tab) before matching.",
-    "For full rewrites prefer FileWrite.",
-].join(" ");
-export const fileEditTool = {
-    name: "FileEdit",
-    description: DESCRIPTION,
-    parameters: {
-        type: "object",
-        properties: {
-            path: { type: "string" },
-            old_string: { type: "string" },
-            new_string: { type: "string" },
-            replace_all: { type: "boolean", description: "replace all occurrences (default false)" },
-        },
-        required: ["path", "old_string", "new_string"],
-    },
-    async execute(args) {
-        const path = args.path;
-        const oldStr = args.old_string;
-        const newStr = args.new_string;
-        const all = args.replace_all === true;
-        if (!path)
-            throw new Error("path is required");
-        if (!oldStr)
-            throw new Error("old_string is required");
-        if (newStr === undefined)
-            throw new Error("new_string is required");
-        const content = await readFile(path, "utf-8");
-        if (!content.includes(oldStr))
-            throw new Error(`old_string not found in ${path}`);
-        if (all) {
-            await writeFile(path, content.split(oldStr).join(newStr), "utf-8");
-            return `Edited ${path} (replaced all)`;
-        }
-        const count = content.split(oldStr).length - 1;
-        if (count > 1)
-            throw new Error(`old_string appears ${count} times in ${path}, must be unique (or set replace_all)`);
-        await writeFile(path, content.replace(oldStr, newStr), "utf-8");
-        return `Edited ${path}`;
-    },
-    summaryArg: "path",
-};

package/dist/tools/file_read.js

@@ -1,43 +0,0 @@
-import { readFile } from "node:fs/promises";
-const DEFAULT_LIMIT = 2000;
-const DESCRIPTION = [
-    "Read a file's contents as UTF-8 text, returned with line numbers (cat -n format).",
-    "path may be relative (to the working directory) or absolute.",
-    "Reads up to 2000 lines by default; use offset and limit to page through larger files.",
-].join(" ");
-export const fileReadTool = {
-    name: "FileRead",
-    description: DESCRIPTION,
-    parameters: {
-        type: "object",
-        properties: {
-            path: { type: "string" },
-            offset: { type: "number", description: "line number to start reading from (1-indexed)" },
-            limit: { type: "number", description: "number of lines to read (default 2000)" },
-        },
-        required: ["path"],
-    },
-    async execute(args) {
-        const path = args.path;
-        const offset = args.offset || 1;
-        const limit = args.limit || DEFAULT_LIMIT;
-        const content = await readFile(path, "utf-8");
-        if (!content)
-            return "(empty file)";
-        const lines = content.split("\n");
-        const start = Math.max(0, offset - 1);
-        if (start >= lines.length) {
-            return `(offset ${offset} is past end of file; file has ${lines.length} lines)`;
-        }
-        const end = Math.min(lines.length, start + limit);
-        const slice = lines.slice(start, end);
-        let out = slice
-            .map((line, i) => `${String(start + i + 1).padStart(6, " ")}\t${line}`)
-            .join("\n");
-        if (end < lines.length) {
-            out += `\n(${lines.length - end} more lines; use offset=${end + 1} to continue)`;
-        }
-        return out;
-    },
-    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.",
-    "Includes hidden files (e.g. .env, .gitignore); 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, ctx) {
-        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, ctx.signal);
-        return files.length ? files.join("\n") : "(no matches)";
-    },
-    summaryArg: ["pattern", "path"],
-};

package/dist/tools/grep.js

@@ -1,73 +0,0 @@
-import { resolveCwd, runRgLines } from "../util/ripgrep.js";
-const DEFAULT_HEAD_LIMIT = 200;
-const DESCRIPTION = [
-    "Search file contents under a directory recursively for a regex pattern (RE2 syntax).",
-    "Includes hidden files (e.g. .env, .gitignore); skips node_modules and .git.",
-    "By default returns matching lines as path:line:content, capped at 200 lines; use output_mode, head_limit, and context options to control output.",
-].join(" ");
-export const grepTool = {
-    name: "Grep",
-    description: DESCRIPTION,
-    parameters: {
-        type: "object",
-        properties: {
-            pattern: { type: "string" },
-            path: { type: "string", description: "root directory, defaults to cwd" },
-            glob: { type: "string", description: "glob pattern to filter files (e.g. *.ts)" },
-            type: { type: "string", description: "file type to search (e.g. ts, js, py, rust, go)" },
-            output_mode: {
-                type: "string",
-                enum: ["content", "files_with_matches", "count"],
-                description: "content (default, matching lines), files_with_matches (file paths only), count (match counts per file)",
-            },
-            ignore_case: { type: "boolean", description: "case-insensitive match" },
-            before: { type: "number", description: "lines to show before each match" },
-            after: { type: "number", description: "lines to show after each match" },
-            context: { type: "number", description: "lines to show before and after each match" },
-            only_matching: { type: "boolean", description: "print only the matched (non-empty) parts" },
-            multiline: { type: "boolean", description: "allow patterns to span newlines" },
-            head_limit: { type: "number", description: "max output lines (default 200)" },
-        },
-        required: ["pattern"],
-    },
-    async execute(args, ctx) {
-        const cwd = resolveCwd(args.path);
-        const rgArgs = ["--line-number", "--with-filename", "--no-heading"];
-        if (args.ignore_case)
-            rgArgs.push("-i");
-        if (args.only_matching)
-            rgArgs.push("-o");
-        if (args.multiline)
-            rgArgs.push("-U", "--multiline-dotall");
-        const context = args.context;
-        if (context)
-            rgArgs.push("-C", String(context));
-        else {
-            const before = args.before;
-            const after = args.after;
-            if (before)
-                rgArgs.push("-B", String(before));
-            if (after)
-                rgArgs.push("-A", String(after));
-        }
-        if (args.glob)
-            rgArgs.push("-g", args.glob);
-        if (args.type)
-            rgArgs.push("-t", args.type);
-        const output_mode = args.output_mode || "content";
-        if (output_mode === "files_with_matches")
-            rgArgs.push("-l");
-        else if (output_mode === "count")
-            rgArgs.push("-c");
-        rgArgs.push(args.pattern, ".");
-        const lines = await runRgLines(rgArgs, cwd, ctx.signal);
-        if (!lines.length)
-            return "(no matches)";
-        const headLimit = args.head_limit || DEFAULT_HEAD_LIMIT;
-        if (lines.length > headLimit) {
-            return lines.slice(0, headLimit).join("\n") + `\n(${lines.length - headLimit} more matches, truncated)`;
-        }
-        return lines.join("\n");
-    },
-    summaryArg: ["pattern", "path"],
-};

package/dist/tools/registry.js

@@ -1,52 +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";
-import { askUserTool } from "./ask_user.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, ctx) {
-        const tool = this.tools.get(name);
-        if (!tool)
-            return { content: `Error: unknown tool ${name}`, isError: true };
-        try {
-            const r = await tool.execute(args, ctx);
-            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, askUserTool])
-        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, ctx) {
-        const command = args.command;
-        const r = await runProcess(shell, [...shellArgs, commandPrefix + command], {}, ctx.signal);
-        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,141 +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, ctx) {
-        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",
-                signal: ctx.signal,
-            });
-        }
-        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/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,43 +0,0 @@
-import { spawn } from "node:child_process";
-const MAX_BUFFER = 10 * 1024 * 1024;
-export function runProcess(cmd, args, opts = {}, signal) {
-    return new Promise((resolve) => {
-        const child = spawn(cmd, args, {
-            cwd: opts.cwd,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        const onAbort = () => child.kill();
-        if (signal) {
-            signal.addEventListener("abort", onAbort, { once: true });
-            if (signal.aborted)
-                onAbort();
-        }
-        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) => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve({ stdout: "", stderr: "", status: null, error });
-        });
-        child.on("close", (status) => {
-            signal?.removeEventListener("abort", onAbort);
-            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, signal) {
-    const rgArgs = ["--hidden", "--path-separator", "/", "-g", "!.git/**", "-g", "!node_modules/**", ...args];
-    const r = await runProcess(rgPath, rgArgs, { cwd }, signal);
-    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(/^\.\//, ""));
-}