@vietor/easy-agent 0.3.1 → 0.4.2

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/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(/^\.\//, ""));
-}