@vietor/agent-core 0.7.0

package/dist/tools/sub-agent.js

@@ -0,0 +1,81 @@
+import { NOT_EXECUTED_PREFIX } from "../util/constants.js";
+import { toolError } from "./types.js";
+export const SUB_AGENT_GUIDANCE = '- Consider delegating to the SubAgent tool when the task matches an agent type, when you have independent work to run in parallel, or when answering would mean reading across several files — delegate and keep the conclusion, not the file dumps. type: "explore" — read-only search agent for broad fan-out searches (state the search breadth in the task); type: "plan" — software architect producing implementation plans. For a single-fact lookup where you already know the file, symbol, or value, search directly. Once you have delegated a search, do not also run it yourself — wait for the result. Issue at most 2 SubAgent calls per turn; multiple calls in the same turn run concurrently. Sub-agents are read-only and return only their final report, not intermediate steps — verify important results yourself. For large workloads with many independent items that would exceed the turn budget, split the items into chunks sized so each sub-agent can complete its chunk within its own loop budget, delegate one SubAgent per chunk, and run the remaining chunks in the following turns as results return. Instruct each sub-agent to report results per item in structured lines so you can consolidate.';
+const EXPLORE_PROMPT = [
+    "You are the Explore sub-agent — a read-only search agent for broad fan-out searches. Use it when answering means sweeping many files, directories, or naming conventions and the parent needs only the conclusion, not the file dumps. You read excerpts rather than whole files, so you locate code — you do not review or audit it. You are read-only: you must not modify any files.",
+    "Guidelines:",
+    '- If the parent stated a search breadth, match your effort to it: "medium" for moderate exploration, "very thorough" for multiple locations and naming conventions.',
+    "- Use Grep and Glob to locate matches first, then read only the excerpts needed to extract the facts — not whole files.",
+    "- Follow imports and call sites to trace definitions when the answer depends on how code connects.",
+    "- Trust tool results as ground truth; do not guess file contents from memory.",
+    "- If the task is ambiguous, state your assumptions explicitly.",
+    '- Report in concise markdown: a summary of findings first, then details with file_path:line_number references, and a final "Bottom line" section with a direct answer to the task.',
+    "- Keep the reply proportionate to the question — typically 10-40 lines; extract key facts rather than pasting file contents.",
+].join("\n");
+const PLAN_PROMPT = [
+    "You are the Plan sub-agent — a software architect. Produce a step-by-step implementation plan for the given task. Read the relevant code first to ground the plan in the actual code, then design the plan. You are read-only: you must not modify any files or implement anything.",
+    "Guidelines:",
+    "- First locate the relevant code: read the files the task mentions and confirm real function signatures, module structure, and existing conventions before planning.",
+    "- Consider architectural trade-offs: note the alternative approaches and why the recommended one was chosen.",
+    "- Output a numbered step-by-step plan in markdown. For each step give the file paths to create or modify, the function or type signatures involved, and a one-line rationale. Order steps by dependency.",
+    "- Identify the critical files for implementation — the files the implementer must read first.",
+    '- End with a short "Risks & open questions" section listing anything to verify during implementation.',
+    '- End with a short "Verification" section: the commands, tests, or manual checks to run to confirm each step works.',
+    "- Keep the plan concise — typically 20-50 lines.",
+    "- Be specific and actionable; do not speculate beyond what you read.",
+].join("\n");
+const SUB_AGENT_DEFS = [
+    {
+        type: "explore",
+        name: "Explore",
+        description: "Read-only search agent for broad fan-out searches across the codebase or web; locate code via excerpts, does not review or audit.",
+        systemPrompt: EXPLORE_PROMPT,
+    },
+    {
+        type: "plan",
+        name: "Plan",
+        description: "Software architect that produces a step-by-step implementation plan grounded in the actual code.",
+        systemPrompt: PLAN_PROMPT,
+    },
+];
+const TOOL_DESCRIPTION = 'Run a dedicated sub-agent in its own nested loop — the only result you receive is its final report as text, not intermediate steps. type: "explore" — a read-only search agent for broad fan-out searches of the codebase or web; specify a search breadth in the task ("medium" for moderate exploration, "very thorough" for multiple locations and naming conventions). type: "plan" — a software architect that reads the relevant code first, then returns a step-by-step implementation plan identifying critical files and architectural trade-offs. Sub-agents are read-only and cannot ask questions, use skills, or spawn further sub-agents.';
+export function createSubAgentTool(deps) {
+    return {
+        name: "SubAgent",
+        description: TOOL_DESCRIPTION,
+        parameters: {
+            type: "object",
+            properties: {
+                type: {
+                    type: "string",
+                    enum: SUB_AGENT_DEFS.map((d) => d.type),
+                    description: 'The sub-agent type to invoke: "explore" (read-only fan-out search) or "plan" (implementation plan).',
+                },
+                task: { type: "string", description: "The task or question for the sub-agent, as a self-contained description." },
+            },
+            required: ["type", "task"],
+        },
+        summaryKeys: ["type"],
+        async execute(args, ctx) {
+            const type = args.type;
+            const task = (args.task ?? "").trim();
+            const def = SUB_AGENT_DEFS.find((d) => d.type === type);
+            if (!def) {
+                return toolError(`unknown sub-agent type "${type}". Valid types: ${SUB_AGENT_DEFS.map((d) => d.type).join(", ")}`);
+            }
+            if (!task) {
+                return toolError("task is required");
+            }
+            const { status, reply, messages } = await deps.runSubAgent(def.systemPrompt, task, ctx.signal);
+            if (status === "ok")
+                return { content: reply };
+            const stallReason = status === "stalled"
+                ? [...messages].reverse()
+                    .map((m) => m.content)
+                    .find((c) => typeof c === "string" && c.startsWith(NOT_EXECUTED_PREFIX))
+                : undefined;
+            const suffix = stallReason ? ` ${stallReason}` : "";
+            return { content: `Sub-agent "${type}" ended with status ${status}.${suffix}\n\n${reply}`, isError: true };
+        },
+    };
+}

package/dist/tools/todo-write.d.ts

@@ -0,0 +1,3 @@
+import type { Tool, Todo } from "./types.js";
+export declare const TODO_WRITE_GUIDANCE = "- For multi-step tasks (3+ steps), you MUST use TodoWrite: create the task list first, then update each task's status as you execute. Never execute a multi-step task without a TodoWrite task list.";
+export declare function createTodoWriteTool(setTodos: (todos: Todo[]) => void): Tool;

package/dist/tools/todo-write.js

@@ -0,0 +1,72 @@
+import { toolError } from "./types.js";
+export const TODO_WRITE_GUIDANCE = "- For multi-step tasks (3+ steps), you MUST use TodoWrite: create the task list first, then update each task's status as you execute. Never execute a multi-step task without a TodoWrite task list.";
+const STATUSES = ["pending", "inProgress", "completed"];
+const DESCRIPTION = "Manage the task list for tasks with 3+ steps. Pass the FULL list each call; it replaces the previous list. Keep one inProgress at a time. status: pending, inProgress, completed.";
+function parseTodos(args) {
+    const raw = args.todos;
+    if (!Array.isArray(raw)) {
+        return { todos: [], done: 0, normalized: 0, error: `"todos" must be an array of {content, status} objects, got ${typeof raw}` };
+    }
+    const todos = [];
+    let done = 0;
+    let normalized = 0;
+    let seenInProgress = false;
+    for (const t of raw) {
+        if (!t)
+            continue;
+        const content = typeof t.content === "string" ? t.content.trim() : "";
+        if (!content)
+            continue;
+        let status = STATUSES.includes(t.status) ? t.status : "pending";
+        if (status === "inProgress") {
+            if (seenInProgress) {
+                status = "pending";
+                normalized++;
+            }
+            else {
+                seenInProgress = true;
+            }
+        }
+        else if (status === "completed") {
+            done++;
+        }
+        todos.push({ content, status });
+    }
+    return { todos, done, normalized };
+}
+export function createTodoWriteTool(setTodos) {
+    return {
+        name: "TodoWrite",
+        description: DESCRIPTION,
+        parameters: {
+            type: "object",
+            properties: {
+                todos: {
+                    type: "array",
+                    description: "The full task list, in execution order.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            content: { type: "string", description: "A short imperative description of the step." },
+                            status: { type: "string", enum: STATUSES, description: "Current status of the step." },
+                        },
+                        required: ["content", "status"],
+                    },
+                },
+            },
+            required: ["todos"],
+        },
+        summarizeArgs(args) {
+            const { todos, done, error } = parseTodos(args);
+            return error ? "invalid" : `${done}/${todos.length}`;
+        },
+        async execute(args, _ctx) {
+            const { todos, done, normalized, error } = parseTodos(args);
+            if (error)
+                return toolError(error);
+            setTodos(todos);
+            const note = normalized ? ` (normalized ${normalized} item${normalized === 1 ? "" : "s"} to one inProgress)` : "";
+            return { content: `Updated task list (${todos.length} item${todos.length === 1 ? "" : "s"}, ${done} done)${note}.` };
+        },
+    };
+}

package/dist/tools/types.d.ts

@@ -0,0 +1,32 @@
+export interface TextResult {
+    content: string;
+    isError?: boolean;
+}
+export declare function toolError(msg: string): TextResult;
+export type TodoStatus = "pending" | "inProgress" | "completed";
+export interface Todo {
+    content: string;
+    status: TodoStatus;
+}
+export interface ToolContext {
+    cwd: string;
+    signal?: AbortSignal;
+}
+export interface ToolSchema {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export interface Tool {
+    name: string;
+    readOnly?: boolean;
+    description: string;
+    parameters: Record<string, unknown>;
+    summaryKeys?: string[];
+    summarizeArgs?: (args: Record<string, unknown>) => string;
+    summarizeResult?(result: TextResult): string;
+    execute(args: Record<string, unknown>, ctx: ToolContext): Promise<TextResult>;
+}

package/dist/tools/types.js

@@ -0,0 +1,4 @@
+export function toolError(msg) {
+    const content = msg.startsWith("Error: ") ? msg : `Error: ${msg}`;
+    return { content: content, isError: true };
+}

package/dist/tools/web-fetch.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from "./types.js";
+export declare const webFetchTool: Tool;

package/dist/tools/web-fetch.js

@@ -0,0 +1,104 @@
+import { netFetch } from "../util/net.js";
+import { backoffDelay, isAbortError, withRetry, withTimeoutFn } from "../util/async.js";
+import { MAX_WEB_FETCH_MB, mbToBytes, REQUEST_TIMEOUT_MS, WEB_FETCH_RETRIES } from "../util/constants.js";
+import { htmlToMarkdown } from "../util/html.js";
+import { toErrorMessage, summaryBytes } from "../util/text.js";
+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 RETRYABLE_STATUS = new Set([408, 429, 500, 502, 503, 504]);
+const MAX_WEB_FETCH_BYTES = mbToBytes(MAX_WEB_FETCH_MB);
+const REQUEST_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",
+    "Accept": "text/markdown,text/html,text/plain,application/xhtml+xml,application/xml,application/json;q=0.9,image/webp,*/*;q=0.8",
+    "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+    "Cache-Control": "no-cache",
+};
+const DESCRIPTION = `Fetch a URL via HTTP GET. Returns raw text for JSON/XML/text; converts HTML to markdown. Rejects binary content and bodies over ${MAX_WEB_FETCH_MB}MB. Retries transient failures (network, timeouts, 429/5xx) up to ${WEB_FETCH_RETRIES + 1} attempts. GET only; no custom headers or request body. Follows redirects.`;
+class WebFetchError extends Error {
+}
+async function readTextBounded(res, maxBytes) {
+    if (!res.body)
+        return "";
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let text = "";
+    let bytes = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        bytes += value.byteLength;
+        if (bytes > maxBytes) {
+            await reader.cancel().catch(() => { });
+            throw new Error(`response body exceeds ${maxBytes} bytes`);
+        }
+        text += decoder.decode(value, { stream: true });
+    }
+    return text + decoder.decode();
+}
+async function fetchOne(url, signal) {
+    const res = await withTimeoutFn((s) => netFetch(url, { headers: REQUEST_HEADERS, redirect: "follow", signal: s }), REQUEST_TIMEOUT_MS, signal, `timed out after ${REQUEST_TIMEOUT_MS / 1000}s`).catch((e) => {
+        if (isAbortError(e))
+            throw e;
+        throw new WebFetchError(`failed to fetch ${url}: ${toErrorMessage(e)}`);
+    });
+    if (!res.ok) {
+        const message = `${res.status} ${res.statusText} for ${url}`;
+        if (RETRYABLE_STATUS.has(res.status))
+            throw new WebFetchError(message);
+        throw new Error(message);
+    }
+    const contentType = res.headers.get("content-type") || "";
+    const mime = mimeFrom(contentType);
+    if (!isTextualMime(mime))
+        throw new Error(`unsupported content type: ${mime} for ${url}`);
+    const contentLength = Number(res.headers.get("content-length"));
+    if (Number.isFinite(contentLength) && contentLength > MAX_WEB_FETCH_BYTES) {
+        throw new Error(`content too large: ${contentLength} bytes for ${url} (limit ${MAX_WEB_FETCH_BYTES})`);
+    }
+    const body = await readTextBounded(res, MAX_WEB_FETCH_BYTES);
+    if (!mime.includes("html"))
+        return body;
+    return htmlToMarkdown(body);
+}
+export const webFetchTool = {
+    name: "WebFetch",
+    readOnly: true,
+    description: DESCRIPTION,
+    parameters: {
+        type: "object",
+        properties: {
+            url: {
+                type: "string",
+                description: "full URL including scheme (http or https)",
+            },
+        },
+        required: ["url"],
+    },
+    async execute(args, ctx) {
+        const url = args.url;
+        return {
+            content: await withRetry(() => fetchOne(url, ctx.signal), {
+                retries: WEB_FETCH_RETRIES,
+                retryable: (e) => e instanceof WebFetchError,
+                backoff: backoffDelay,
+                signal: ctx.signal,
+            }),
+        };
+    },
+    summarizeResult(result) {
+        return summaryBytes("Fetched", result, "Fetch failed");
+    },
+    summaryKeys: ["url"],
+};

package/dist/util/async.d.ts

@@ -0,0 +1,19 @@
+export declare class AbortedError extends Error {
+    constructor();
+}
+export declare function isAbortError(e: unknown): boolean;
+export declare function backoffDelay(attempt: number): number;
+export interface RetryOptions {
+    retries: number;
+    retryable: (e: unknown) => boolean;
+    backoff: (attempt: number) => number;
+    onRetry?: (attempt: number, max: number, error: unknown) => void;
+    signal?: AbortSignal;
+}
+export declare function withRetry<T>(fn: () => Promise<T>, opts: RetryOptions): Promise<T>;
+export declare function withTimeout<T>(p: Promise<T>, ms: number): Promise<T>;
+export declare function withTimeoutSignal(signal: AbortSignal | undefined, ms: number): AbortSignal;
+export declare function isTimeout(signal: AbortSignal): boolean;
+export declare function withAbort<T>(promise: Promise<T>, signal?: AbortSignal, onAbort?: () => T): Promise<T>;
+export declare function mapWithConcurrency<T, R>(items: readonly T[], limit: number, fn: (item: T) => Promise<R>, signal?: AbortSignal): Promise<R[]>;
+export declare function withTimeoutFn<T>(fn: (signal: AbortSignal) => Promise<T>, ms: number, signal: AbortSignal | undefined, timeoutMessage: string, otherError?: (e: unknown) => unknown): Promise<T>;

package/dist/util/async.js

@@ -0,0 +1,93 @@
+export class AbortedError extends Error {
+    constructor() {
+        super("aborted");
+        this.name = "AbortedError";
+    }
+}
+export function isAbortError(e) {
+    if (e instanceof AbortedError)
+        return true;
+    const name = e?.name;
+    return name === "AbortError" || name === "APIUserAbortError";
+}
+export function backoffDelay(attempt) {
+    return 1000 * 2 ** attempt;
+}
+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, e);
+                await trySleep(opts.backoff(attempt), opts.signal);
+                continue;
+            }
+            throw e;
+        }
+    }
+}
+function trySleep(ms, signal) {
+    if (!signal)
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new AbortedError());
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new AbortedError());
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+export function withTimeout(p, ms) {
+    return withTimeoutFn(() => p, ms, undefined, `timeout after ${ms}ms`);
+}
+export function withTimeoutSignal(signal, ms) {
+    return signal ? AbortSignal.any([signal, AbortSignal.timeout(ms)]) : AbortSignal.timeout(ms);
+}
+export function isTimeout(signal) {
+    return signal.reason?.name === "TimeoutError";
+}
+export function withAbort(promise, signal, onAbort) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return onAbort ? Promise.resolve(onAbort()) : Promise.reject(new AbortedError());
+    return new Promise((resolve, reject) => {
+        const handleAbort = () => { if (onAbort)
+            resolve(onAbort());
+        else
+            reject(new AbortedError()); };
+        signal.addEventListener("abort", handleAbort, { once: true });
+        promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", handleAbort));
+    });
+}
+export async function mapWithConcurrency(items, limit, fn, signal) {
+    const results = [];
+    for (let i = 0; i < items.length; i += limit) {
+        if (signal?.aborted)
+            break;
+        const chunk = items.slice(i, i + limit);
+        results.push(...(await Promise.all(chunk.map((item) => fn(item)))));
+    }
+    return results;
+}
+export async function withTimeoutFn(fn, ms, signal, timeoutMessage, otherError) {
+    const timed = withTimeoutSignal(signal, ms);
+    try {
+        return await fn(timed);
+    }
+    catch (e) {
+        if (isTimeout(timed))
+            throw new Error(timeoutMessage);
+        throw otherError ? otherError(e) : e;
+    }
+}

package/dist/util/constants.d.ts

@@ -0,0 +1,25 @@
+export declare const MAX_PROCESS_BUFFER_MB = 10;
+export declare const MAX_WEB_FETCH_MB = 10;
+export declare const MAX_FILE_READ_MB = 20;
+export declare const CALL_TIMEOUT_MS = 300000;
+export declare const REQUEST_TIMEOUT_MS = 60000;
+export declare const MCP_CONNECT_TIMEOUT_MS = 30000;
+export declare const NO_OUTPUT = "(no output)";
+export declare const INTERRUPTED_TOOL_CONTENT = "(interrupted)";
+export declare const NO_MATCHES = "(no matches)";
+export declare const NOT_EXECUTED_PREFIX = "(not executed: ";
+export declare const MAX_SUMMARY_LENGTH = 75;
+export declare const MAX_ARGS_SUMMARY_LENGTH = 300;
+export declare const DEFAULT_STALL_THRESHOLD = 3;
+export declare const DEFAULT_MAX_TURNS = 50;
+export declare const DEFAULT_FILE_READ_LIMIT = 2000;
+export declare const DEFAULT_GREP_LIMIT = 200;
+export declare const MAX_PARALLEL_TOOL_CALLS = 8;
+export declare const SKILL_TOOL_NAME: "Skill";
+export declare const LLM_MAX_RETRIES = 3;
+export declare const WEB_FETCH_RETRIES = 2;
+export declare const DEFAULT_THINKING_EFFORT: "high";
+export declare const DEFAULT_BACKEND: "completions";
+export declare const DEFAULT_MAX_INPUT_TOKENS = 1000000;
+export declare const DEFAULT_MAX_OUTPUT_TOKENS = 128000;
+export declare function mbToBytes(mb: number): number;

package/dist/util/constants.js

@@ -0,0 +1,27 @@
+export const MAX_PROCESS_BUFFER_MB = 10;
+export const MAX_WEB_FETCH_MB = 10;
+export const MAX_FILE_READ_MB = 20;
+export const CALL_TIMEOUT_MS = 300_000;
+export const REQUEST_TIMEOUT_MS = 60_000;
+export const MCP_CONNECT_TIMEOUT_MS = 30_000;
+export const NO_OUTPUT = "(no output)";
+export const INTERRUPTED_TOOL_CONTENT = "(interrupted)";
+export const NO_MATCHES = "(no matches)";
+export const NOT_EXECUTED_PREFIX = "(not executed: ";
+export const MAX_SUMMARY_LENGTH = 75;
+export const MAX_ARGS_SUMMARY_LENGTH = 300;
+export const DEFAULT_STALL_THRESHOLD = 3;
+export const DEFAULT_MAX_TURNS = 50;
+export const DEFAULT_FILE_READ_LIMIT = 2000;
+export const DEFAULT_GREP_LIMIT = 200;
+export const MAX_PARALLEL_TOOL_CALLS = 8;
+export const SKILL_TOOL_NAME = "Skill";
+export const LLM_MAX_RETRIES = 3;
+export const WEB_FETCH_RETRIES = 2;
+export const DEFAULT_THINKING_EFFORT = "high";
+export const DEFAULT_BACKEND = "completions";
+export const DEFAULT_MAX_INPUT_TOKENS = 1_000_000;
+export const DEFAULT_MAX_OUTPUT_TOKENS = 128_000;
+export function mbToBytes(mb) {
+    return mb * 1024 * 1024;
+}

package/dist/util/emitter.d.ts

@@ -0,0 +1,5 @@
+export declare class Emitter<T extends (...args: any[]) => void = () => void> {
+    private listeners;
+    subscribe(listener: T): () => void;
+    notify(...args: Parameters<T>): void;
+}

package/dist/util/emitter.js

@@ -0,0 +1,15 @@
+export class Emitter {
+    listeners = new Set();
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    notify(...args) {
+        for (const l of this.listeners) {
+            try {
+                l(...args);
+            }
+            catch { /* isolate listener errors */ }
+        }
+    }
+}

package/dist/util/file.d.ts

@@ -0,0 +1,3 @@
+export declare function tryReadFileText(path: string): string | undefined;
+export declare function resolveRequiredPath(args: Record<string, unknown>, cwd: string): string;
+export declare function resolveOptionalPath(args: Record<string, unknown>, cwd: string): string;

package/dist/util/file.js

@@ -0,0 +1,19 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+export function tryReadFileText(path) {
+    if (existsSync(path)) {
+        const content = readFileSync(path, "utf-8").trim();
+        if (content)
+            return content;
+    }
+    return undefined;
+}
+export function resolveRequiredPath(args, cwd) {
+    const path = args.path;
+    if (typeof path !== "string" || !path)
+        throw new Error("path is required");
+    return resolve(cwd, path);
+}
+export function resolveOptionalPath(args, cwd) {
+    return resolve(cwd, args.path || "");
+}

package/dist/util/html.d.ts

@@ -0,0 +1 @@
+export declare function htmlToMarkdown(html: string): string;

package/dist/util/html.js

@@ -0,0 +1,14 @@
+import TurndownService from "turndown";
+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"]);
+export function htmlToMarkdown(html) {
+    return turndown.turndown(html);
+}

package/dist/util/index.d.ts

@@ -0,0 +1,7 @@
+export { AbortedError, backoffDelay, isAbortError, mapWithConcurrency, withAbort, withRetry, withTimeout, withTimeoutFn, type RetryOptions } from "./async.js";
+export { DEFAULT_BACKEND, DEFAULT_MAX_INPUT_TOKENS, DEFAULT_MAX_OUTPUT_TOKENS, DEFAULT_THINKING_EFFORT } from "./constants.js";
+export { tryReadFileText } from "./file.js";
+export { htmlToMarkdown } from "./html.js";
+export { netFetch } from "./net.js";
+export { type ProcessResult, runProcess } from "./subprocess.js";
+export { formatCompactNumber, formatDuration, getTextBytes, summarizeText, toErrorMessage } from "./text.js";

package/dist/util/index.js

@@ -0,0 +1,7 @@
+export { AbortedError, backoffDelay, isAbortError, mapWithConcurrency, withAbort, withRetry, withTimeout, withTimeoutFn } from "./async.js";
+export { DEFAULT_BACKEND, DEFAULT_MAX_INPUT_TOKENS, DEFAULT_MAX_OUTPUT_TOKENS, DEFAULT_THINKING_EFFORT } from "./constants.js";
+export { tryReadFileText } from "./file.js";
+export { htmlToMarkdown } from "./html.js";
+export { netFetch } from "./net.js";
+export { runProcess } from "./subprocess.js";
+export { formatCompactNumber, formatDuration, getTextBytes, summarizeText, toErrorMessage } from "./text.js";

package/dist/util/net.d.ts

@@ -0,0 +1 @@
+export declare function netFetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;

package/dist/util/net.js

@@ -0,0 +1,31 @@
+import { ProxyAgent } from "undici";
+let proxyAgent;
+let noProxyList;
+let proxyInitialized = false;
+function ensureProxy() {
+    proxyInitialized = true;
+    const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
+    const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
+    const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+    const proxyUrl = httpsProxy || httpProxy;
+    proxyAgent = proxyUrl ? new ProxyAgent(proxyUrl) : null;
+    noProxyList = noProxy?.split(",").map((s) => s.trim()).filter(Boolean);
+}
+export async function netFetch(input, init) {
+    if (!proxyInitialized)
+        ensureProxy();
+    if (!proxyAgent)
+        return fetch(input, init);
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    if (noProxyList) {
+        const hostname = new URL(url).hostname;
+        const shouldBypass = noProxyList.some((p) => {
+            if (p.startsWith("."))
+                return hostname.endsWith(p);
+            return hostname === p || hostname.endsWith("." + p);
+        });
+        if (shouldBypass)
+            return fetch(input, init);
+    }
+    return fetch(input, { ...init, dispatcher: proxyAgent });
+}

package/dist/util/ripgrep.d.ts

@@ -0,0 +1,10 @@
+export declare function formatRipgrepOutput(lines: string[], truncated: boolean, emptyText: string): string;
+export declare function ripgrepResultSummary(word: "file" | "match", result: {
+    content: string;
+    isError?: boolean;
+}, failText: string, noMatchesText: string): string;
+export interface RipgrepLinesResult {
+    lines: string[];
+    truncated: boolean;
+}
+export declare function runRipgrepLines(args: string[], cwd: string, signal?: AbortSignal, limit?: number): Promise<RipgrepLinesResult>;

package/dist/util/ripgrep.js

@@ -0,0 +1,34 @@
+import { rgPath } from "@vscode/ripgrep";
+import { runProcess } from "./subprocess.js";
+import { NO_MATCHES, REQUEST_TIMEOUT_MS } from "./constants.js";
+import { countNonEmptyLines, summaryCount } from "./text.js";
+const TRUNCATION_MARKER = "(output truncated)";
+export function formatRipgrepOutput(lines, truncated, emptyText) {
+    if (!lines.length)
+        return emptyText;
+    const out = lines.join("\n");
+    return truncated ? out + "\n" + TRUNCATION_MARKER : out;
+}
+export function ripgrepResultSummary(word, result, failText, noMatchesText) {
+    if (result.isError)
+        return failText;
+    if (result.content === NO_MATCHES)
+        return noMatchesText;
+    const lines = countNonEmptyLines(result.content);
+    const count = lines - (result.content.endsWith(TRUNCATION_MARKER) ? 1 : 0);
+    return summaryCount(word, count, false, failText);
+}
+export async function runRipgrepLines(args, cwd, signal, limit) {
+    const rgArgs = ["--hidden", "--path-separator", "/", "-g", "!.git/**", "-g", "!node_modules/**", ...args];
+    const r = await runProcess(rgPath, rgArgs, { cwd, timeout: REQUEST_TIMEOUT_MS }, signal);
+    if (!r.truncated && (r.error || (r.status !== 0 && r.status !== 1))) {
+        throw r.error ?? new Error((r.stderr || "").trim() || `ripgrep exited with ${r.status}`);
+    }
+    let kept = r.stdout.split("\n").filter(Boolean);
+    let truncated = r.truncated === true;
+    if (limit !== undefined && kept.length > limit) {
+        kept = kept.slice(0, limit);
+        truncated = true;
+    }
+    return { lines: kept.map((f) => f.replace(/^\.\//, "")), truncated };
+}