min-agent 0.5.0 → 0.6.0

package/dist/tools/grep.js

@@ -1,174 +0,0 @@
-import { tool, jsonSchema } from "ai";
-import { readdir, readFile, stat } from "fs/promises";
-import { spawn } from "child_process";
-import path from "path";
-import { truncateToolOutput } from "../tool-output.js";
-import { pathAccessError } from "../sandbox.js";
-const IGNORED_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", ".out", "coverage", ".min-agent"]);
-const MAX_RESULTS = 500;
-const MAX_FILE_BYTES = 5 * 1024 * 1024;
-const MAX_RG_OUTPUT_BYTES = 8 * 1024 * 1024;
-const WALK_CONCURRENCY = 8;
-/** Convert a simple glob like "*.ts" into an anchored regex for file names. */
-function globToRegex(glob) {
-    const escaped = glob
-        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
-        .replace(/\*/g, ".*")
-        .replace(/\?/g, ".");
-    return new RegExp(`^${escaped}$`);
-}
-/** Fast path: shell out to ripgrep when available. Resolves null if rg is missing or fails. */
-function rgSearch(pattern, root, includeRegex, ignore) {
-    const args = [
-        "--no-heading",
-        "--line-number",
-        "-i",
-        "-e",
-        pattern,
-        "--max-count",
-        "1",
-        "-g",
-        "!*.lock",
-        "--max-filesize",
-        String(MAX_FILE_BYTES),
-    ];
-    for (const dir of ignore)
-        args.push("-g", `!${dir}/**`);
-    if (includeRegex) {
-        const glob = includeRegex.source.replace(/^\^/, "").replace(/\$$/, "").replace(/\\\./g, ".").replace(/\.\*/g, "*");
-        args.push("-g", glob);
-    }
-    args.push(root);
-    return new Promise((resolve) => {
-        const child = spawn("rg", args, { stdio: ["ignore", "pipe", "pipe"] });
-        const chunks = [];
-        let total = 0;
-        let settled = false;
-        const finish = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            resolve(value);
-        };
-        const timer = setTimeout(() => {
-            child.kill("SIGKILL");
-            finish(null);
-        }, 15000);
-        child.stdout.on("data", (chunk) => {
-            total += chunk.byteLength;
-            if (total > MAX_RG_OUTPUT_BYTES) {
-                child.kill("SIGKILL");
-                finish(null);
-                return;
-            }
-            chunks.push(chunk);
-        });
-        child.on("error", () => finish(null));
-        child.on("close", (code) => {
-            if (code === 1)
-                finish([]);
-            else if (code === 0)
-                finish(Buffer.concat(chunks).toString("utf-8").split("\n").filter(Boolean).slice(0, MAX_RESULTS));
-            else
-                finish(null);
-        });
-    });
-}
-async function walk(dir, regex, includeRegex, results) {
-    const dirQueue = [dir];
-    const worker = async () => {
-        while (dirQueue.length > 0 && results.length < MAX_RESULTS) {
-            const current = dirQueue.pop();
-            let entries;
-            try {
-                entries = await readdir(current, { withFileTypes: true });
-            }
-            catch {
-                continue;
-            }
-            await Promise.all(entries.map(async (entry) => {
-                const full = path.join(current, entry.name);
-                if (entry.isDirectory()) {
-                    if (!IGNORED_DIRS.has(entry.name) && results.length < MAX_RESULTS)
-                        dirQueue.push(full);
-                    return;
-                }
-                if (!entry.isFile())
-                    return;
-                if (includeRegex && !includeRegex.test(entry.name))
-                    return;
-                try {
-                    const info = await stat(full);
-                    if (info.size > MAX_FILE_BYTES)
-                        return;
-                    const content = await readFile(full, "utf-8");
-                    if (content.includes("\0"))
-                        return;
-                    const lines = content.split("\n");
-                    for (let i = 0; i < lines.length && results.length < MAX_RESULTS; i++) {
-                        if (regex.test(lines[i])) {
-                            results.push(`${path.relative(process.cwd(), full)}:${i + 1}:${lines[i]}`);
-                        }
-                    }
-                }
-                catch {
-                    // unreadable file — skip
-                }
-            }));
-        }
-    };
-    await Promise.all(Array.from({ length: WALK_CONCURRENCY }, worker));
-}
-export const grepTool = tool({
-    description: "Search for a pattern in files using regex. Returns matching lines with file paths and line numbers. Use this to find code references, usages, and definitions.",
-    inputSchema: jsonSchema({
-        type: "object",
-        properties: {
-            pattern: { type: "string", description: "The regex pattern to search for" },
-            path: { type: "string", description: "File or directory path to search in (defaults to current directory)" },
-            include: { type: "string", description: "File pattern to include (e.g. '*.ts')" },
-        },
-        required: ["pattern"],
-    }),
-    execute: async ({ pattern, path: searchPath, include }) => {
-        try {
-            const regex = new RegExp(pattern);
-            const includeRegex = include ? globToRegex(include) : null;
-            const root = path.resolve(process.cwd(), searchPath ?? ".");
-            const denied = pathAccessError(root, "read");
-            if (denied)
-                return `Error: ${denied}`;
-            const results = [];
-            const info = await stat(root).catch(() => null);
-            if (!info)
-                return `Error: path not found: ${searchPath ?? "."}`;
-            if (info.isFile()) {
-                try {
-                    const content = await readFile(root, "utf-8");
-                    if (!content.includes("\0")) {
-                        content.split("\n").forEach((line, i) => {
-                            if (regex.test(line))
-                                results.push(`${root}:${i + 1}:${line}`);
-                        });
-                    }
-                }
-                catch { }
-            }
-            else {
-                const rgResults = await rgSearch(pattern, root, includeRegex, [...IGNORED_DIRS]);
-                if (rgResults !== null) {
-                    results.push(...rgResults);
-                }
-                else {
-                    await walk(root, regex, includeRegex, results);
-                }
-            }
-            const text = results.length > 0 ? results.join("\n") : "No matches found";
-            return truncateToolOutput(text, { direction: "head" }).content;
-        }
-        catch (err) {
-            return `Error: ${err.message}`;
-        }
-    },
-});

package/dist/tools/index.js

@@ -1,34 +0,0 @@
-import { bashTool } from "./bash.js";
-import { readTool } from "./read.js";
-import { writeTool } from "./write.js";
-import { editTool } from "./edit.js";
-import { applyPatchTool } from "./apply_patch.js";
-import { globTool } from "./glob.js";
-import { grepTool } from "./grep.js";
-import { webSearchTool } from "./web_search.js";
-import { webFetchTool } from "./web_fetch.js";
-import { questionTool } from "./question.js";
-import { codeSearchTool } from "./code_search.js";
-/**
- * Builtin tools shared by main runs and sub-agents. `todo` is deliberately
- * absent: it must be bound to a per-run TaskState, so callers register their
- * own instance via createTodoTool.
- */
-export function createTools() {
-    const tools = {
-        bash: bashTool,
-        read: readTool,
-        write: writeTool,
-        edit: editTool,
-        apply_patch: applyPatchTool,
-        glob: globTool,
-        grep: grepTool,
-        search_web: webSearchTool,
-        web_fetch: webFetchTool,
-        question: questionTool,
-    };
-    if (process.env.EXA_API_KEY) {
-        tools.codesearch = codeSearchTool;
-    }
-    return tools;
-}

package/dist/tools/question.js

@@ -1,54 +0,0 @@
-import { tool, jsonSchema } from "ai";
-import { askQuestion } from "../confirm.js";
-import { normalizeQuestionOptions, normalizeQuestionPrompt } from "../question-format.js";
-export const questionTool = tool({
-    description: `Ask the user a question to get clarification before proceeding. Use this when:
-- The task is ambiguous and you need more information
-- There are multiple valid approaches and you want the user to choose
-- You need confirmation before a potentially destructive action
-- You're unsure about a requirement or preference
-
-Provide a clear, specific question. Optional choices should be an array of strings. Object items with label/description are also accepted.`,
-    inputSchema: jsonSchema({
-        type: "object",
-        properties: {
-            question: { type: "string", description: "The question to ask the user" },
-            options: {
-                type: "array",
-                items: {
-                    anyOf: [
-                        { type: "string" },
-                        {
-                            type: "object",
-                            properties: {
-                                label: { type: "string" },
-                                description: { type: "string" },
-                                key: { type: "string" },
-                            },
-                        },
-                    ],
-                },
-                description: "Optional list of choices. Prefer plain strings; {label, description} objects are also accepted.",
-            },
-        },
-        required: ["question"],
-    }),
-    execute: async ({ question, options }) => {
-        const prompt = normalizeQuestionPrompt(question);
-        if (!prompt.trim())
-            return "Error: question is required.";
-        const choices = normalizeQuestionOptions(options);
-        const answer = await askQuestion(prompt, choices.length > 0 ? choices : undefined);
-        if (answer === null)
-            return "User cancelled the question";
-        if (choices.length > 0) {
-            const exact = choices.find((c) => c === answer);
-            if (exact)
-                return `User chose: ${exact}`;
-            const idx = parseInt(answer, 10) - 1;
-            if (Number.isInteger(idx) && idx >= 0 && idx < choices.length)
-                return `User chose: ${choices[idx]}`;
-        }
-        return `User answered: ${answer}`;
-    },
-});

package/dist/tools/read.js

@@ -1,109 +0,0 @@
-import { tool, jsonSchema } from "ai";
-import { createReadStream } from "fs";
-import { stat, readFile } from "fs/promises";
-import { createInterface } from "readline";
-import path from "path";
-import { TOOL_OUTPUT_MAX_BYTES, truncateToolOutput } from "../tool-output.js";
-import { getActiveInstructionTracker } from "../instructions.js";
-import { pathAccessError } from "../sandbox.js";
-/** Files above this size are streamed instead of loaded into memory. */
-const STREAM_THRESHOLD_BYTES = 20 * 1024 * 1024;
-/** Stream lines [start, end] (1-indexed, inclusive) without loading the whole file. */
-function readLineRange(filePath, start, end) {
-    return new Promise((resolve, reject) => {
-        const lines = [];
-        const rl = createInterface({ input: createReadStream(filePath), crlfDelay: Infinity });
-        let i = 0;
-        rl.on("line", (line) => {
-            i++;
-            if (i >= start && i <= end)
-                lines.push(line);
-            if (i > end)
-                rl.close();
-        });
-        rl.on("close", () => resolve(lines.join("\n")));
-        rl.on("error", reject);
-    });
-}
-/** Stream the first maxBytes of a file, cut on a UTF-8 safe boundary. */
-function readStreamHead(filePath, maxBytes) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        let total = 0;
-        let truncated = false;
-        let totalLines = 0;
-        const stream = createReadStream(filePath);
-        stream.on("data", (chunk) => {
-            const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-            total += buf.byteLength;
-            if (total > maxBytes) {
-                const keep = buf.byteLength - (total - maxBytes);
-                chunks.push(buf.subarray(0, keep));
-                truncated = true;
-                stream.destroy();
-                return;
-            }
-            chunks.push(buf);
-        });
-        stream.on("close", () => {
-            totalLines = Buffer.concat(chunks).toString("utf-8").split("\n").length;
-            resolve({ text: Buffer.concat(chunks).toString("utf-8"), truncated, totalLines });
-        });
-        stream.on("error", reject);
-    });
-}
-export const readTool = tool({
-    description: "Read the contents of a file. Returns the file content as text. Use this to understand code, check configurations, etc.",
-    inputSchema: jsonSchema({
-        type: "object",
-        properties: {
-            filePath: { type: "string", description: "Path to the file to read (relative to cwd or absolute)" },
-            startLine: { type: "number", description: "Start line number (1-indexed)" },
-            endLine: { type: "number", description: "End line number (1-indexed, inclusive)" },
-        },
-        required: ["filePath"],
-    }),
-    execute: async ({ filePath, startLine, endLine }) => {
-        const denied = pathAccessError(filePath, "read");
-        if (denied)
-            return `Error: ${denied}`;
-        const resolved = path.resolve(process.cwd(), filePath);
-        try {
-            const info = await stat(resolved);
-            if (info.isDirectory())
-                return `Error: ${filePath} is a directory, not a file`;
-            if (info.size > STREAM_THRESHOLD_BYTES && !startLine && !endLine) {
-                const { text, truncated, totalLines } = await readStreamHead(resolved, TOOL_OUTPUT_MAX_BYTES);
-                let result = text;
-                if (truncated) {
-                    result += `\n\n...(file too large: ${info.size} bytes, ${totalLines}+ lines — use startLine/endLine to read specific ranges)...`;
-                }
-                return result;
-            }
-            let result;
-            if (startLine != null || endLine != null) {
-                const start = startLine ?? 1;
-                const end = endLine ?? Number.MAX_SAFE_INTEGER;
-                if (start < 1)
-                    return `Error: startLine must be >= 1`;
-                if (endLine != null && end < start)
-                    return `Error: endLine (${end}) must be >= startLine (${start})`;
-                result = await readLineRange(resolved, start, end);
-                if (!result)
-                    return `Error: no lines found in range ${start}-${end}`;
-            }
-            else {
-                result = await readFile(resolved, "utf-8");
-            }
-            // Context-aware: discover nearby instruction files
-            const nearbyInstructions = getActiveInstructionTracker().resolveForFile(resolved);
-            if (nearbyInstructions.length > 0) {
-                result += "\n\n<system-reminder>\n" + nearbyInstructions.join("\n\n") + "\n</system-reminder>";
-            }
-            return truncateToolOutput(result, { direction: "head" }).content;
-        }
-        catch (err) {
-            return `Error reading file: ${err.message}`;
-        }
-    },
-});

package/dist/tools/search-searxng.js

@@ -1,223 +0,0 @@
-import { loadConfig } from "../config.js";
-import { truncateToolOutput } from "../tool-output.js";
-import { configHint, resolveBackendBase } from "./backend.js";
-import { LANGUAGE_RE, MAX_BODY_BYTES, VALID_TIME_RANGES, clamp, collapse, dedupeByUrl, emptyResponse, fetchJsonOutcome, formatResults, isString, resolveMaxResults, } from "./web_search.js";
-/** SearXNG is used when explicitly configured (webSearchURL / MIN_AGENT_SEARXNG_URL). */
-export const SEARXNG_BACKEND = {
-    envName: "MIN_AGENT_SEARXNG_URL",
-    configKey: "webSearchURL",
-    fallback: "https://searxng.xc.lonae.com",
-};
-const SEARCH_TIMEOUT_MS = 20000;
-const DEFAULT_FALLBACK_ENGINES = "google,bing";
-export function searxngConfigured() {
-    const env = process.env[SEARXNG_BACKEND.envName];
-    if (env?.trim())
-        return true;
-    const configured = loadConfig().webSearchURL;
-    return !!configured?.trim();
-}
-function asResult(r) {
-    if (typeof r !== "object" || r === null)
-        return null;
-    const o = r;
-    if (!isString(o.url))
-        return null;
-    return {
-        title: isString(o.title) ? o.title : "",
-        url: o.url,
-        content: isString(o.content) ? o.content : "",
-        engine: isString(o.engine) ? o.engine : "",
-        score: typeof o.score === "number" ? o.score : 0,
-        publishedDate: isString(o.publishedDate) ? o.publishedDate : "",
-        imgSrc: isString(o.img_src) ? o.img_src : isString(o.thumbnail) ? o.thumbnail : "",
-    };
-}
-function parseResponse(data) {
-    if (typeof data !== "object" || data === null)
-        return emptyResponse();
-    const o = data;
-    const results = (Array.isArray(o.results) ? o.results : [])
-        .map(asResult)
-        .filter((r) => r !== null);
-    // Some engines return answers as objects ({ answer, url }) rather than plain strings.
-    const answers = (Array.isArray(o.answers) ? o.answers : [])
-        .map((a) => {
-        if (isString(a))
-            return a;
-        if (typeof a === "object" && a !== null) {
-            const rec = a;
-            if (isString(rec.answer))
-                return rec.answer;
-            if (isString(rec.content))
-                return rec.content;
-        }
-        return "";
-    })
-        .filter((a) => a !== "");
-    const suggestions = Array.isArray(o.suggestions) ? o.suggestions.filter(isString) : [];
-    const corrections = Array.isArray(o.corrections) ? o.corrections.filter(isString) : [];
-    const infoboxes = (Array.isArray(o.infoboxes) ? o.infoboxes : [])
-        .map((b) => {
-        if (typeof b !== "object" || b === null)
-            return null;
-        const box = b;
-        return {
-            infobox: isString(box.infobox) ? box.infobox : "",
-            content: isString(box.content) ? box.content : "",
-        };
-    })
-        .filter((b) => b !== null && (b.infobox !== "" || b.content !== ""));
-    const unresponsive = (Array.isArray(o.unresponsive_engines) ? o.unresponsive_engines : [])
-        .map((e) => {
-        if (!Array.isArray(e) || !isString(e[0]))
-            return null;
-        return [e[0], isString(e[1]) ? e[1] : ""];
-    })
-        .filter((e) => e !== null);
-    return { results, answers, suggestions, corrections, infoboxes, unresponsive_engines: unresponsive };
-}
-async function searchOnce(base, params) {
-    return fetchJsonOutcome(`${base}/search?${params}`, { headers: { Accept: "application/json" }, signal: AbortSignal.timeout(SEARCH_TIMEOUT_MS) }, parseResponse);
-}
-function renderFailure(o) {
-    const hint = configHint(SEARXNG_BACKEND);
-    switch (o.kind) {
-        case "network":
-            return `Search error: could not reach the search backend (${o.message}). The instance may be down or the network may be unavailable — this is not a problem with the query. ${hint}`;
-        case "invalid-json":
-            if (o.bodyTooLarge) {
-                return `Search error: the search backend response exceeded ${MAX_BODY_BYTES / 1024 / 1024} MB and could not be parsed. Narrow the query or request fewer engines.`;
-            }
-            return `Search error: the search backend returned a non-JSON response${o.sample ? ` (starts with: ${o.sample})` : ""}. The instance most likely has the JSON output format disabled. ${hint}`;
-        case "http": {
-            const detail = o.backendMessage ? ` Backend message: ${o.backendMessage}.` : "";
-            if (o.status === 429) {
-                return `Search error: the search backend is rate-limiting (HTTP 429).${detail} Wait a few seconds before retrying, or use a different instance. ${hint}`;
-            }
-            if (o.status === 401 || o.status === 403) {
-                return `Search error: the search backend rejected the request (HTTP ${o.status}).${detail} The instance likely requires authentication or has the JSON output format disabled. ${hint}`;
-            }
-            if (o.status === 400 || o.status === 422) {
-                return `Search error: the search backend rejected these parameters (HTTP ${o.status}).${detail} Fix the arguments and retry; retrying with the same values will fail again.`;
-            }
-            if (o.status >= 500) {
-                return `Search error: the search backend failed with HTTP ${o.status}.${detail} It may be temporarily overloaded — retry once, then try a different instance. ${hint}`;
-            }
-            return `Search error: HTTP ${o.status} from the search backend.${detail} ${hint}`;
-        }
-    }
-}
-function fallbackEngines() {
-    const env = process.env.MIN_AGENT_SEARXNG_FALLBACK_ENGINES;
-    if (env !== undefined)
-        return env.trim();
-    const configured = loadConfig().webSearchFallbackEngines;
-    if (configured !== undefined)
-        return configured.trim();
-    return DEFAULT_FALLBACK_ENGINES;
-}
-/** Validate/normalize the model-supplied arguments, collecting notes for anything ignored. */
-function buildParams(input, notes) {
-    const params = new URLSearchParams({ q: input.query, format: "json", categories: "general" });
-    const lang = (input.language ?? "").trim();
-    if (lang) {
-        if (LANGUAGE_RE.test(lang))
-            params.set("language", lang.replace("_", "-"));
-        else
-            notes.push(`ignored invalid language "${lang}"; use a code like "zh", "en" or "zh-CN"`);
-    }
-    const range = (input.time_range ?? "").trim().toLowerCase();
-    if (range) {
-        if (VALID_TIME_RANGES.has(range))
-            params.set("time_range", range);
-        else
-            notes.push(`ignored invalid time_range "${range}"; valid values: day, week, month, year`);
-    }
-    return params;
-}
-/**
- * SearXNG reports the instance-wide unresponsive list regardless of which
- * engines a request used, so narrow it to the requested set when there is one
- * and say so otherwise.
- */
-function unresponsiveHint(engines, requested) {
-    let relevant = engines;
-    if (requested && requested.length > 0) {
-        const wanted = new Set(requested.map((e) => e.toLowerCase()));
-        relevant = engines.filter(([name]) => wanted.has(name.toLowerCase()));
-    }
-    if (relevant.length === 0)
-        return "";
-    const detail = relevant.map(([name, reason]) => (reason ? `${name} (${reason})` : name)).join(", ");
-    const scope = requested
-        ? "The requested engines are unavailable"
-        : "The backend reports these engines as unavailable (instance-wide list, may include engines this query did not use)";
-    return `${scope}: ${detail}. Try a different query, or pass "engines" explicitly (e.g. "google,bing").`;
-}
-export async function runSearxng(input, query, notes) {
-    const resolved = resolveBackendBase(SEARXNG_BACKEND, loadConfig().webSearchURL);
-    if (!resolved.ok)
-        return `Search error: ${resolved.error}. ${configHint(SEARXNG_BACKEND)}`;
-    const maxResults = resolveMaxResults(input.max_results, notes);
-    const params = buildParams({ ...input, query }, notes);
-    let outcome = await searchOnce(resolved.base, params);
-    // The default engine set on a given instance can be entirely blocked
-    // (CAPTCHA / rate limits), which looks identical to "no such page exists".
-    // A single retry against known-good engines distinguishes the two. The
-    // unresponsive list is instance-wide and therefore not a reliable trigger.
-    let usedFallback = null;
-    if (outcome.kind === "ok" && outcome.data.results.length === 0) {
-        const fallback = fallbackEngines();
-        if (fallback) {
-            const retryParams = new URLSearchParams(params);
-            retryParams.set("engines", fallback);
-            const retry = await searchOnce(resolved.base, retryParams);
-            if (retry.kind === "ok" && retry.data.results.length > 0) {
-                outcome = retry;
-                usedFallback = fallback;
-            }
-            else if (retry.kind !== "ok") {
-                notes.push(`the fallback engines (${fallback}) also failed: ${renderFailure(retry).replace(/^Search error: /, "")}`);
-            }
-        }
-    }
-    if (outcome.kind !== "ok")
-        return renderFailure(outcome);
-    const data = outcome.data;
-    const results = dedupeByUrl(data.results).slice(0, maxResults);
-    const noteBlock = notes.map((n) => `Note: ${n}`).join("\n");
-    if (results.length === 0) {
-        const parts = [`No search results found for "${query}".`];
-        if (noteBlock)
-            parts.push(noteBlock);
-        const hint = unresponsiveHint(data.unresponsive_engines, usedFallback ? usedFallback.split(",") : null);
-        if (hint)
-            parts.push(hint);
-        if (data.corrections.length > 0)
-            parts.push(`Did you mean: ${data.corrections.join(", ")}`);
-        if (data.suggestions.length > 0)
-            parts.push(`Related queries: ${data.suggestions.slice(0, 8).join(", ")}`);
-        if (!hint && data.corrections.length === 0 && data.suggestions.length === 0) {
-            parts.push("Try a different query or a broader wording.");
-        }
-        return parts.join("\n\n");
-    }
-    // Direct answers and infoboxes carry the highest information density, so
-    // they precede the result list.
-    const sections = [];
-    if (noteBlock)
-        sections.push(noteBlock);
-    for (const a of data.answers)
-        sections.push(`Answer: ${collapse(a)}`);
-    for (const b of data.infoboxes) {
-        sections.push(`Infobox${b.infobox ? ` (${collapse(b.infobox)})` : ""}: ${clamp(collapse(b.content), 600)}`);
-    }
-    sections.push(`Found ${results.length} result${results.length === 1 ? "" : "s"} for "${query}"${usedFallback ? ` via fallback engines ${usedFallback}` : ""}:`);
-    sections.push(formatResults(results));
-    if (data.corrections.length > 0)
-        sections.push(`Did you mean: ${data.corrections.join(", ")}`);
-    if (data.suggestions.length > 0)
-        sections.push(`Related queries: ${data.suggestions.slice(0, 8).join(", ")}`);
-    return truncateToolOutput(sections.join("\n\n"), { direction: "head" }).content;
-}