min-agent 0.5.0 → 0.6.0

package/dist/tool-output.js

@@ -1,126 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, writeFileSync } from "fs";
-import path from "path";
-import { randomBytes } from "crypto";
-import { getConfigDir } from "./config.js";
-/** Default limits (aligned with common agent tooling practice). */
-export const TOOL_OUTPUT_MAX_LINES = 2000;
-export const TOOL_OUTPUT_MAX_BYTES = 50 * 1024;
-const RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
-const CLEANUP_INTERVAL_MS = 10 * 60 * 1000;
-let lastCleanup = 0;
-function toolOutputDir() {
-    return path.join(getConfigDir(), "tool-output");
-}
-function cleanupOldToolOutputs(dir) {
-    const now = Date.now();
-    if (now - lastCleanup < CLEANUP_INTERVAL_MS)
-        return;
-    lastCleanup = now;
-    if (!existsSync(dir))
-        return;
-    try {
-        for (const f of readdirSync(dir)) {
-            if (!f.startsWith("tool-") || !f.endsWith(".txt"))
-                continue;
-            const p = path.join(dir, f);
-            try {
-                if (now - statSync(p).mtimeMs > RETENTION_MS)
-                    unlinkSync(p);
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-    catch {
-        /* ignore */
-    }
-}
-/** Write full text to ~/.min-agent/tool-output/ and return absolute path. */
-export function writeFullToolOutput(fullText) {
-    const dir = toolOutputDir();
-    mkdirSync(dir, { recursive: true });
-    cleanupOldToolOutputs(dir);
-    const name = `tool-${Date.now()}-${randomBytes(4).toString("hex")}.txt`;
-    const filePath = path.join(dir, name);
-    writeFileSync(filePath, fullText, "utf-8");
-    return filePath;
-}
-const hint = (filePath) => `The tool output was truncated. Full output saved to: ${filePath}\nUse the read tool with startLine/endLine, or grep, to inspect further.`;
-/** Keep start or end of text within line/byte limits (good for shell logs / files). */
-function preview(text, maxLines, maxBytes, direction, lines, totalBytes) {
-    if (lines.length <= maxLines && totalBytes <= maxBytes) {
-        return { text, cut: false };
-    }
-    const out = [];
-    let bytes = 0;
-    const pushLine = (i, first) => {
-        const size = Buffer.byteLength(lines[i], "utf-8") + (first ? 0 : 1);
-        if (bytes + size > maxBytes)
-            return false;
-        if (direction === "head")
-            out.push(lines[i]);
-        else
-            out.unshift(lines[i]);
-        bytes += size;
-        return true;
-    };
-    if (direction === "head") {
-        for (let i = 0; i < lines.length && out.length < maxLines; i++) {
-            if (!pushLine(i, out.length === 0)) {
-                if (out.length === 0) {
-                    const buf = Buffer.from(lines[i], "utf-8");
-                    let end = Math.min(maxBytes, buf.length);
-                    while (end > 0 && (buf[end] & 0xc0) === 0x80)
-                        end--;
-                    out.push(buf.subarray(0, end).toString("utf-8"));
-                }
-                break;
-            }
-        }
-    }
-    else {
-        for (let i = lines.length - 1; i >= 0 && out.length < maxLines; i--) {
-            if (!pushLine(i, out.length === 0)) {
-                if (out.length === 0) {
-                    const buf = Buffer.from(lines[i], "utf-8");
-                    let start = buf.length - maxBytes;
-                    if (start < 0)
-                        start = 0;
-                    while (start < buf.length && (buf[start] & 0xc0) === 0x80)
-                        start++;
-                    out.unshift(buf.subarray(start).toString("utf-8"));
-                }
-                break;
-            }
-        }
-    }
-    return { text: out.join("\n"), cut: true };
-}
-/** Keep end of text within line/byte limits (good for shell logs). */
-export function tailPreview(text, maxLines, maxBytes) {
-    return preview(text, maxLines, maxBytes, "tail", text.split("\n"), Buffer.byteLength(text, "utf-8"));
-}
-/** Keep start of text within line/byte limits (good for files / HTTP bodies). */
-export function headPreview(text, maxLines, maxBytes) {
-    return preview(text, maxLines, maxBytes, "head", text.split("\n"), Buffer.byteLength(text, "utf-8"));
-}
-/**
- * If text exceeds limits, write full text to disk and return a preview + path hint.
- * Otherwise returns the original string.
- */
-export function truncateToolOutput(text, options = {}) {
-    const maxLines = options.maxLines ?? TOOL_OUTPUT_MAX_LINES;
-    const maxBytes = options.maxBytes ?? TOOL_OUTPUT_MAX_BYTES;
-    const direction = options.direction ?? "head";
-    const lines = text.split("\n");
-    const totalBytes = Buffer.byteLength(text, "utf-8");
-    if (lines.length <= maxLines && totalBytes <= maxBytes) {
-        return { content: text, truncated: false };
-    }
-    const filePath = writeFullToolOutput(text);
-    const pv = preview(text, maxLines, maxBytes, direction, lines, totalBytes);
-    const header = "...output truncated...\n\n";
-    const content = direction === "tail" ? `${header}${hint(filePath)}\n\n${pv.text}` : `${pv.text}\n\n${header}${hint(filePath)}`;
-    return { content, truncated: true, outputPath: filePath };
-}

package/dist/tools/apply_patch.js

@@ -1,265 +0,0 @@
-import { tool, jsonSchema } from "ai";
-import { readFileSync, existsSync } from "fs";
-import { mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
-import path from "path";
-import { confirm, isEditAutoApprove } from "../confirm.js";
-import { pathAccessError } from "../sandbox.js";
-import { atomicWriteFile, tempPathFor } from "./atomic-file.js";
-const OFFSET_TOLERANCE = 3;
-export function parseUnifiedDiff(diff) {
-    const files = [];
-    let current = null;
-    let currentHunk = null;
-    let pendingHeader = null;
-    let remainingOld = 0;
-    let remainingNew = 0;
-    const lines = diff.replace(/\r\n/g, "\n").split("\n");
-    for (const raw of lines) {
-        if (currentHunk === null && raw.startsWith("--- ")) {
-            pendingHeader = raw.slice(4);
-            continue;
-        }
-        if (currentHunk === null && pendingHeader !== null && raw.startsWith("+++ ")) {
-            const target = raw.slice(4);
-            if (current)
-                files.push(current);
-            current = { path: stripPrefix(target), isNew: pendingHeader === "/dev/null", hunks: [] };
-            currentHunk = null;
-            pendingHeader = null;
-            continue;
-        }
-        if (currentHunk === null && raw.startsWith("@@ ")) {
-            const m = raw.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
-            if (m && current) {
-                currentHunk = {
-                    oldStart: parseInt(m[1], 10),
-                    oldCount: m[2] ? parseInt(m[2], 10) : 1,
-                    newStart: parseInt(m[3], 10),
-                    newCount: m[4] ? parseInt(m[4], 10) : 1,
-                    lines: [],
-                };
-                current.hunks.push(currentHunk);
-                remainingOld = currentHunk.oldCount;
-                remainingNew = currentHunk.newCount;
-            }
-            continue;
-        }
-        if (currentHunk && current) {
-            if (raw.startsWith("+")) {
-                currentHunk.lines.push({ type: "add", text: raw.slice(1) });
-                remainingNew--;
-            }
-            else if (raw.startsWith("-")) {
-                currentHunk.lines.push({ type: "delete", text: raw.slice(1) });
-                remainingOld--;
-            }
-            else if (raw.startsWith(" ")) {
-                currentHunk.lines.push({ type: "context", text: raw.slice(1) });
-                remainingOld--;
-                remainingNew--;
-            }
-            if (remainingOld <= 0 && remainingNew <= 0)
-                currentHunk = null;
-        }
-    }
-    if (current)
-        files.push(current);
-    return files;
-}
-function stripPrefix(p) {
-    const trimmed = p.trim();
-    if (trimmed === "/dev/null")
-        return trimmed;
-    if (trimmed.startsWith("a/"))
-        return trimmed.slice(2);
-    if (trimmed.startsWith("b/"))
-        return trimmed.slice(2);
-    return trimmed;
-}
-function findMatch(lines, start, block) {
-    if (block.length === 0)
-        return Math.max(0, Math.min(start, lines.length));
-    for (let pos = Math.max(0, start - OFFSET_TOLERANCE); pos <= Math.min(lines.length - block.length, start + OFFSET_TOLERANCE); pos++) {
-        let ok = true;
-        for (let i = 0; i < block.length; i++) {
-            if (lines[pos + i] !== block[i]) {
-                ok = false;
-                break;
-            }
-        }
-        if (ok)
-            return pos;
-    }
-    return -1;
-}
-function applyHunk(lines, hunk) {
-    const block = hunk.lines.filter((l) => l.type !== "add").map((l) => l.text);
-    const pos = findMatch(lines, hunk.oldStart - 1, block);
-    if (pos === -1) {
-        return { error: `第 ${hunk.oldStart} 行附近的 hunk 未找到匹配（需要匹配 ${block.length} 行）` };
-    }
-    const result = [...lines.slice(0, pos)];
-    let src = pos;
-    for (const l of hunk.lines) {
-        if (l.type === "context") {
-            result.push(lines[src]);
-            src++;
-        }
-        else if (l.type === "delete") {
-            src++;
-        }
-        else {
-            result.push(l.text);
-        }
-    }
-    result.push(...lines.slice(src));
-    return { lines: result };
-}
-/** 在内存中应用全部文件；成功后返回各文件新内容（不写盘）。 */
-export function buildPatchedFiles(files, cwd = process.cwd()) {
-    const contents = [];
-    for (const file of files) {
-        const target = path.resolve(cwd, file.path);
-        const exists = existsSync(target);
-        if (file.isNew && !exists) {
-            const lines = [];
-            for (const hunk of file.hunks) {
-                const r = applyHunk(lines, hunk);
-                if ("error" in r)
-                    return { ok: false, error: `${file.path}: ${r.error}` };
-                lines.length = 0;
-                lines.push(...r.lines);
-            }
-            contents.push({ file, content: lines.join("\n") + (lines.length > 0 ? "\n" : ""), original: null });
-            continue;
-        }
-        if (!exists)
-            return { ok: false, error: `${file.path}: 文件不存在` };
-        let content;
-        try {
-            content = readFileSync(target, "utf-8");
-        }
-        catch (err) {
-            return { ok: false, error: `${file.path}: 读取失败 ${err instanceof Error ? err.message : String(err)}` };
-        }
-        const lines = content.split("\n");
-        for (const hunk of file.hunks) {
-            const r = applyHunk(lines, hunk);
-            if ("error" in r)
-                return { ok: false, error: `${file.path}: ${r.error}` };
-            lines.length = 0;
-            lines.push(...r.lines);
-        }
-        contents.push({ file, content: lines.join("\n"), original: content });
-    }
-    return { ok: true, contents };
-}
-function errMessage(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-/**
- * 事务化写盘：先把所有新内容写入目标旁的临时文件，再统一 rename 就位。
- * 第一阶段失败时工作区零改动；rename 中途失败时回滚已就位的文件。
- */
-async function commitPatchedFiles(contents) {
-    const cwd = process.cwd();
-    const staged = [];
-    // 漂移检查：确认弹窗期间文件可能被用户或其他进程改动。
-    for (const c of contents) {
-        const target = path.resolve(cwd, c.file.path);
-        if (c.original === null) {
-            if (existsSync(target))
-                return { ok: false, error: `${c.file.path}: 文件已存在，未应用任何更改` };
-            continue;
-        }
-        let current;
-        try {
-            current = await readFile(target, "utf-8");
-        }
-        catch (err) {
-            return { ok: false, error: `${c.file.path}: 读取失败 ${errMessage(err)}` };
-        }
-        if (current !== c.original) {
-            return { ok: false, error: `${c.file.path}: 文件在确认期间已被修改，未应用任何更改` };
-        }
-    }
-    for (const c of contents) {
-        const target = path.resolve(cwd, c.file.path);
-        const tmp = tempPathFor(target);
-        try {
-            await mkdir(path.dirname(target), { recursive: true });
-            await writeFile(tmp, c.content, "utf-8");
-        }
-        catch (err) {
-            for (const s of staged)
-                await unlink(s.tmp).catch(() => { });
-            await unlink(tmp).catch(() => { });
-            return { ok: false, error: `${c.file.path}: 写入失败 ${errMessage(err)}` };
-        }
-        staged.push({ rel: c.file.path, target, tmp, original: c.original });
-    }
-    const renamed = [];
-    for (const s of staged) {
-        try {
-            await rename(s.tmp, s.target);
-            renamed.push(s);
-        }
-        catch (err) {
-            for (const d of [...renamed].reverse()) {
-                try {
-                    if (d.original !== null)
-                        await atomicWriteFile(d.target, d.original);
-                    else
-                        await unlink(d.target).catch(() => { });
-                }
-                catch { }
-            }
-            for (const s2 of staged.slice(renamed.length))
-                await unlink(s2.tmp).catch(() => { });
-            return { ok: false, error: `${s.rel}: 写入失败 ${errMessage(err)}，已回滚其他文件` };
-        }
-    }
-    return { ok: true };
-}
-export const applyPatchTool = tool({
-    description: "Apply a unified diff to the working tree. Use this for precise multi-file edits or when you have a generated diff. " +
-        "Supports standard unified diff format (---/+++ headers, @@ hunks, context/delete/add lines). " +
-        "New files are created when the diff targets /dev/null. Conflicts are reported without partial writes.",
-    inputSchema: jsonSchema({
-        type: "object",
-        properties: {
-            diff: { type: "string", description: "The unified diff text to apply" },
-        },
-        required: ["diff"],
-    }),
-    execute: async ({ diff }) => {
-        const parsed = parseUnifiedDiff(diff);
-        if (parsed.length === 0)
-            return "Error: 无法解析 diff（缺少 ---/+++ 文件头）";
-        // 先鉴权再读盘：任何目标路径不可写都直接拒绝，不触碰文件内容。
-        for (const f of parsed) {
-            const denied = pathAccessError(f.path, "write");
-            if (denied)
-                return `Error: ${denied}`;
-        }
-        const built = buildPatchedFiles(parsed);
-        if (!built.ok)
-            return `Error: ${built.error}`;
-        const summary = built.contents
-            .map((c) => {
-            const del = c.file.hunks.reduce((s, h) => s + h.lines.filter((l) => l.type === "delete").length, 0);
-            const add = c.file.hunks.reduce((s, h) => s + h.lines.filter((l) => l.type === "add").length, 0);
-            return `  ${c.file.path} ${c.file.isNew ? "(new)" : ""} -${del}/+${add}`;
-        })
-            .join("\n");
-        if (!isEditAutoApprove()) {
-            const approved = await confirm(`Apply patch to ${built.contents.length} file(s)?\n${summary}`);
-            if (!approved)
-                return "Patch rejected by user.";
-        }
-        const committed = await commitPatchedFiles(built.contents);
-        if (!committed.ok)
-            return `Error: ${committed.error}`;
-        return `Applied patch:\n${summary}`;
-    },
-});

package/dist/tools/atomic-file.js

@@ -1,35 +0,0 @@
-import { writeFile, rename, unlink } from "fs/promises";
-import { writeFileSync, renameSync, unlinkSync } from "fs";
-import { randomBytes } from "crypto";
-import path from "path";
-/** Temp file path living next to the target so the rename stays on the same filesystem. */
-export function tempPathFor(target) {
-    return path.join(path.dirname(target), `.${path.basename(target)}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`);
-}
-/** Write content to a sibling temp file, then atomically rename it over the target. */
-export async function atomicWriteFile(target, content) {
-    const tmp = tempPathFor(target);
-    try {
-        await writeFile(tmp, content, "utf-8");
-        await rename(tmp, target);
-    }
-    catch (err) {
-        await unlink(tmp).catch(() => { });
-        throw err;
-    }
-}
-/** Sync variant for call sites that must stay synchronous (config/session stores). */
-export function atomicWriteFileSync(target, content) {
-    const tmp = tempPathFor(target);
-    try {
-        writeFileSync(tmp, content, "utf-8");
-        renameSync(tmp, target);
-    }
-    catch (err) {
-        try {
-            unlinkSync(tmp);
-        }
-        catch { }
-        throw err;
-    }
-}

package/dist/tools/backend.js

@@ -1,61 +0,0 @@
-/**
- * Shared plumbing for the HTTP-backed tools (`search_web`, `web_fetch`):
- * base-URL resolution, consistent "how to configure this" copy, and fetch
- * error description. Kept separate so both tools report problems the same way.
- */
-/** Human-readable pointer to both configuration channels. */
-export function configHint(spec) {
-    return `Configure a working instance via "${spec.configKey}" in ~/.min-agent/config.json or the ${spec.envName} env var.`;
-}
-/**
- * Normalize a user-supplied base URL: trim whitespace and trailing slashes so
- * callers can always append "/path" without producing a double slash.
- * Returns an error string for anything that is not an absolute http(s) URL.
- */
-export function normalizeBaseURL(raw, source) {
-    const trimmed = raw.trim();
-    if (trimmed === "")
-        return { ok: false, error: `${source} is empty` };
-    let parsed;
-    try {
-        parsed = new URL(trimmed);
-    }
-    catch {
-        return { ok: false, error: `${source} is not a valid absolute URL: ${trimmed}` };
-    }
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-        return { ok: false, error: `${source} must use http or https, got "${parsed.protocol}"` };
-    }
-    // Keep any path prefix (instances behind a reverse proxy subpath) but drop
-    // query/hash and trailing slashes.
-    parsed.search = "";
-    parsed.hash = "";
-    return { ok: true, base: parsed.toString().replace(/\/+$/, "") };
-}
-/**
- * Resolve a backend base URL. The environment variable wins over the config
- * file so a single run can be redirected from the shell without editing
- * config.json; the built-in default is the last resort.
- */
-export function resolveBackendBase(spec, configValue) {
-    const env = process.env[spec.envName];
-    if (env?.trim())
-        return normalizeBaseURL(env, spec.envName);
-    if (configValue?.trim())
-        return normalizeBaseURL(configValue, `"${spec.configKey}" in config.json`);
-    return normalizeBaseURL(spec.fallback, "the built-in default backend URL");
-}
-/** Turn a thrown fetch error into a short, actionable sentence. */
-export function describeFetchError(err) {
-    if (err instanceof Error) {
-        // AbortSignal.timeout rejects with a TimeoutError DOMException.
-        if (err.name === "TimeoutError" || err.name === "AbortError")
-            return "the request timed out";
-        const cause = err.cause;
-        const causeCode = typeof cause === "object" && cause !== null ? cause.code : undefined;
-        if (typeof causeCode === "string")
-            return `${err.message} (${causeCode})`;
-        return err.message;
-    }
-    return String(err);
-}