min-agent 0.2.1 → 0.4.0

package/dist/title-gen.js

@@ -16,7 +16,10 @@ export async function generateTitle(model, messages) {
     const userContent = typeof userMsg.content === "string"
         ? userMsg.content
         : Array.isArray(userMsg.content)
-            ? userMsg.content.filter((p) => "text" in p).map((p) => p.text).join(" ")
+            ? userMsg.content
+                .filter((p) => "text" in p)
+                .map((p) => p.text ?? "")
+                .join(" ")
             : "";
     if (!userContent.trim())
         return null;
@@ -38,8 +41,12 @@ export async function generateTitle(model, messages) {
                 { role: "user", content: context },
             ],
             temperature: 0.5,
+            maxOutputTokens: 30,
         });
-        const title = result.text.trim().replace(/^["']|["']$/g, "").slice(0, 60);
+        const title = result.text
+            .trim()
+            .replace(/^["']|["']$/g, "")
+            .slice(0, 60);
         return title || null;
     }
     catch {

package/dist/token-display.js

@@ -0,0 +1,36 @@
+export function formatTokenCount(n) {
+    const v = Math.max(0, Math.round(n));
+    if (v < 1000)
+        return String(v);
+    if (v < 100_000)
+        return `${(v / 1000).toFixed(1).replace(/\.0$/, "")}k`;
+    if (v < 1_000_000)
+        return `${Math.round(v / 1000)}k`;
+    if (v < 10_000_000)
+        return `${(v / 1_000_000).toFixed(1).replace(/\.0$/, "")}M`;
+    return `${Math.round(v / 1_000_000)}M`;
+}
+export function contextUsagePercent(context, contextWindow) {
+    if (context <= 0 || contextWindow <= 0)
+        return null;
+    return Math.round((context / contextWindow) * 100);
+}
+export function tokenInfoFromTracker(tracker, contextWindow, estimatedContext = 0) {
+    return {
+        context: tracker.lastInputTokens > 0 ? tracker.lastInputTokens : estimatedContext,
+        input: tracker.totalInputTokens,
+        output: tracker.totalOutputTokens,
+        contextWindow,
+    };
+}
+export function formatTokenStatusLabel(info) {
+    const parts = [];
+    const pct = contextUsagePercent(info.context, info.contextWindow);
+    if (pct != null) {
+        parts.push(`${formatTokenCount(info.context)}/${formatTokenCount(info.contextWindow)} ${pct}%`);
+    }
+    if (info.input > 0 || info.output > 0) {
+        parts.push(`累计 ${formatTokenCount(info.input)} in · ${formatTokenCount(info.output)} out`);
+    }
+    return parts.join(" · ");
+}

package/dist/tool-display.js

@@ -0,0 +1,178 @@
+/**
+ * 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";
+        const titles = text.match(/^\d+\.\s+Title\s*:/gm);
+        if (titles && titles.length > 0)
+            return `${titles.length} results`;
+        if (/^Search results for /m.test(text))
+            return "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,8 @@ 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)}`;
+    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

@@ -0,0 +1,265 @@
+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

@@ -0,0 +1,35 @@
+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;
+    }
+}