min-agent 0.2.0 → 0.3.0

package/dist/tool-display.js

@@ -0,0 +1,173 @@
+/**
+ * One-line summaries of tool calls and their results, shared by the TUI
+ * (`⚡ search_web "query" (news)`) and the plain CLI output. Keeping both
+ * surfaces on this module means a tool only needs a summary rule once.
+ *
+ * Summaries are neutral/English because tool names, arguments and paths are.
+ */
+/** Truncate by code point (not UTF-16 unit) so surrogate pairs never split. */
+export function truncateDisplay(text, max) {
+    const chars = Array.from(text);
+    if (chars.length <= max)
+        return text;
+    return chars.slice(0, Math.max(1, max - 1)).join("") + "…";
+}
+/** Collapse whitespace so a multi-line value stays on one row. */
+function oneLine(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function asRecord(input) {
+    return typeof input === "object" && input !== null && !Array.isArray(input)
+        ? input
+        : null;
+}
+function str(rec, key) {
+    const v = rec[key];
+    return typeof v === "string" ? oneLine(v) : "";
+}
+/** Shorten a path to its last two segments (`src/tools/web_search.ts` → `tools/web_search.ts`). */
+function shortPath(p) {
+    const parts = p.split("/").filter(Boolean);
+    return parts.length <= 2 ? p : `…/${parts.slice(-2).join("/")}`;
+}
+/** Generic `key=value` rendering, used for tools without a specific rule. */
+export function formatToolArgs(input, maxValueLen = 60) {
+    const rec = asRecord(input);
+    if (!rec)
+        return "";
+    const parts = [];
+    for (const [k, v] of Object.entries(rec)) {
+        if (v === undefined || v === null)
+            continue;
+        const raw = typeof v === "string" ? oneLine(v) : JSON.stringify(v);
+        if (raw === undefined)
+            continue;
+        parts.push(`${k}=${truncateDisplay(raw, maxValueLen)}`);
+    }
+    return parts.join(" ");
+}
+/**
+ * Summarize a tool call for a single row. `maxLen` bounds the whole summary;
+ * the caller still truncates to the terminal width.
+ */
+export function summarizeToolCall(toolName, input, maxLen = 120) {
+    const rec = asRecord(input);
+    if (!rec)
+        return "";
+    const summary = specificCallSummary(toolName, rec);
+    return truncateDisplay(summary || formatToolArgs(rec, 60), maxLen);
+}
+function specificCallSummary(toolName, rec) {
+    switch (toolName) {
+        case "search_web": {
+            const query = str(rec, "query");
+            if (!query)
+                return "";
+            const facets = [];
+            const categories = str(rec, "categories");
+            if (categories && categories !== "general")
+                facets.push(categories);
+            const language = str(rec, "language");
+            if (language)
+                facets.push(language);
+            const range = str(rec, "time_range");
+            if (range)
+                facets.push(`past ${range}`);
+            const engines = str(rec, "engines");
+            if (engines)
+                facets.push(`via ${engines}`);
+            return `"${query}"${facets.length > 0 ? ` (${facets.join(", ")})` : ""}`;
+        }
+        case "web_fetch": {
+            const url = str(rec, "url");
+            const method = str(rec, "method");
+            return url ? `${method && method.toUpperCase() !== "GET" ? `${method.toUpperCase()} ` : ""}${url}` : "";
+        }
+        case "read": {
+            const p = str(rec, "filePath");
+            if (!p)
+                return "";
+            const start = rec.startLine;
+            const end = rec.endLine;
+            const range = typeof start === "number" || typeof end === "number" ? `:${start ?? 1}-${end ?? ""}` : "";
+            return `${shortPath(p)}${range}`;
+        }
+        case "write":
+        case "edit":
+        case "apply_patch": {
+            const p = str(rec, "filePath") || str(rec, "path");
+            return p ? shortPath(p) : "";
+        }
+        case "bash":
+            return str(rec, "command");
+        case "grep": {
+            const pattern = str(rec, "pattern");
+            if (!pattern)
+                return "";
+            const where = str(rec, "path");
+            const include = str(rec, "include");
+            const scope = [where, include].filter(Boolean).join(" ");
+            return `${pattern}${scope ? ` in ${scope}` : ""}`;
+        }
+        case "glob":
+            return str(rec, "pattern");
+        case "todo": {
+            const todos = rec.todos;
+            return Array.isArray(todos) ? `${todos.length} item${todos.length === 1 ? "" : "s"}` : "";
+        }
+        case "skill":
+            return str(rec, "name");
+        case "question":
+            return str(rec, "question");
+        case "task":
+            return str(rec, "description");
+        case "explore":
+        case "codesearch":
+            return str(rec, "query");
+        default:
+            return "";
+    }
+}
+/** Text form of a tool result, for the expanded view. */
+export function toolResultText(output) {
+    if (typeof output === "string")
+        return output;
+    if (output === undefined || output === null)
+        return "";
+    try {
+        return JSON.stringify(output, null, 2);
+    }
+    catch {
+        return String(output);
+    }
+}
+/**
+ * One-line result summary. `isError` comes from the tool-error stream event;
+ * error strings produced by tools themselves are also recognized.
+ */
+export function summarizeToolResult(toolName, output, isError = false, maxLen = 100) {
+    const text = toolResultText(output).trim();
+    if (text === "")
+        return isError ? "error" : "(empty)";
+    const firstLine = oneLine(text.split("\n", 1)[0] ?? "");
+    if (isError || /^(error|search error)\b/i.test(firstLine)) {
+        return truncateDisplay(firstLine.replace(/^Error:\s*/i, ""), maxLen);
+    }
+    if (toolName === "search_web") {
+        const found = /^Found (\d+) results? for /m.exec(text);
+        if (found)
+            return `${found[1]} results`;
+        if (/^No search results found/m.test(text))
+            return "no results";
+    }
+    if (toolName === "skill") {
+        const loaded = /^<skill_content name="([^"]*)"/m.exec(text);
+        if (loaded)
+            return truncateDisplay(`loaded ${loaded[1]} (${text.split("\n").length} lines)`, maxLen);
+        return truncateDisplay(firstLine, maxLen);
+    }
+    const lineCount = text.split("\n").length;
+    if (lineCount === 1)
+        return truncateDisplay(firstLine, maxLen);
+    return truncateDisplay(`${firstLine} (${lineCount} lines)`, maxLen);
+}

package/dist/tool-output.js

@@ -6,13 +6,18 @@ import { getConfigDir } from "./config.js";
 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;
-    const now = Date.now();
     try {
         for (const f of readdirSync(dir)) {
             if (!f.startsWith("tool-") || !f.endsWith(".txt"))
@@ -42,60 +47,64 @@ export function writeFullToolOutput(fullText) {
     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 end of text within line/byte limits (good for shell logs). */
-export function tailPreview(text, maxLines, maxBytes) {
-    const lines = text.split("\n");
-    const totalBytes = Buffer.byteLength(text, "utf-8");
+/** 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;
-    for (let i = lines.length - 1; i >= 0 && out.length < maxLines; i--) {
-        const size = Buffer.byteLength(lines[i], "utf-8") + (out.length > 0 ? 1 : 0);
-        if (bytes + size > maxBytes) {
-            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"));
+    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;
             }
-            break;
         }
-        out.unshift(lines[i]);
-        bytes += size;
     }
-    return { text: out.join("\n"), cut: true };
-}
-/** Keep start of text within line/byte limits (good for files / HTTP bodies). */
-export function headPreview(text, maxLines, maxBytes) {
-    const lines = text.split("\n");
-    const totalBytes = Buffer.byteLength(text, "utf-8");
-    if (lines.length <= maxLines && totalBytes <= maxBytes) {
-        return { text, cut: false };
-    }
-    const out = [];
-    let bytes = 0;
-    for (let i = 0; i < lines.length && out.length < maxLines; i++) {
-        const size = Buffer.byteLength(lines[i], "utf-8") + (i > 0 ? 1 : 0);
-        if (bytes + size > maxBytes) {
-            if (out.length === 0) {
-                const buf = Buffer.from(lines[i], "utf-8");
-                let end = Math.min(maxBytes, buf.length);
-                while (end > 0 && (buf[end - 1] & 0xc0) === 0x80)
-                    end--;
-                out.push(buf.subarray(0, end).toString("utf-8"));
+    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;
             }
-            break;
         }
-        out.push(lines[i]);
-        bytes += size;
     }
     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.
@@ -110,10 +119,10 @@ export function truncateToolOutput(text, options = {}) {
         return { content: text, truncated: false };
     }
     const filePath = writeFullToolOutput(text);
-    const preview = direction === "tail" ? tailPreview(text, maxLines, maxBytes).text : headPreview(text, maxLines, maxBytes).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${preview}`
-        : `${preview}\n\n${header}${hint(filePath)}`;
+        ? `${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

@@ -0,0 +1,191 @@
+import { tool, jsonSchema } from "ai";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import path from "path";
+import { confirm, isAutoApprove } from "../confirm.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" : "") });
+            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.message}` };
+        }
+        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") });
+    }
+    return { ok: true, contents };
+}
+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（缺少 ---/+++ 文件头）";
+        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 (!isAutoApprove()) {
+            const approved = await confirm(`Apply patch to ${built.contents.length} file(s)?\n${summary}`);
+            if (!approved)
+                return "Patch rejected by user.";
+        }
+        for (const c of built.contents) {
+            const target = path.resolve(process.cwd(), c.file.path);
+            mkdirSync(path.dirname(target), { recursive: true });
+            writeFileSync(target, c.content, "utf-8");
+        }
+        return `Applied patch:\n${summary}`;
+    },
+});

package/dist/tools/backend.js

@@ -0,0 +1,61 @@
+/**
+ * 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 && env.trim())
+        return normalizeBaseURL(env, spec.envName);
+    if (configValue && 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);
+}