@heyhuynhgiabuu/pi-diff 0.7.1 → 0.7.3

package/dist/index.js

@@ -21,16 +21,14 @@
  *   • Async rendering with invalidate() for non-blocking preview
  */
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { extname, relative, resolve } from "node:path";
+import { extname, relative } from "node:path";
 import { codeToANSI } from "@shikijs/cli";
 import * as Diff from "diff";
+import { executeApplyPatch, formatApplyPatchResult } from "./core/apply-patch.js";
 import { configIndicatorStyle } from "./core/config.js";
 import { computeHunkBlocks, getSepStyle, parseDiff, parsePatchFiles, resolveSepStyle, sepLabelSplit, sepLabelUnified, } from "./core/diff.js";
 import { replace } from "./core/replace.js";
 import { registerEditGuard } from "./edit-guard.js";
-import { initHashline } from "./hashline.js";
-import { executeHashlineRead, HASHLINE_EDIT_DESC, HASHLINE_READ_DESC, runHashlineEdit, } from "./core/hashline-execute.js";
-import * as fs from "node:fs";
 import { applyDiffPalette as applySharedDiffPalette, lang as detectDiffLanguage, renderSplit as renderSharedSplit, resolveDiffColors as resolveSharedDiffColors, themeCacheKey as sharedThemeCacheKey, } from "./review/hunk-preview.js";
 const DIFF_PRESETS = {
     default: {
@@ -207,10 +205,7 @@ function autoDeriveBgFromTheme(theme) {
 }
 /** Load diff theme config from .pi/settings.json (project-level, then global). */
 function loadDiffConfig() {
-    const paths = [
-        `${process.cwd()}/.pi/settings.json`,
-        `${process.env.HOME ?? ""}/.pi/settings.json`,
-    ];
+    const paths = [`${process.cwd()}/.pi/settings.json`, `${process.env.HOME ?? ""}/.pi/settings.json`];
     for (const p of paths) {
         try {
             if (existsSync(p)) {
@@ -923,10 +918,7 @@ async function renderUnified(diff, language, max = MAX_RENDER_LINES, dc = DEFAUL
             newSrc.push(l.content);
     }
     const [oldHL, newHL] = canHL
-        ? await Promise.all([
-            hlBlock(oldSrc.join("\n"), language),
-            hlBlock(newSrc.join("\n"), language),
-        ])
+        ? await Promise.all([hlBlock(oldSrc.join("\n"), language), hlBlock(newSrc.join("\n"), language)])
         : [oldSrc, newSrc];
     let oI = 0, nI = 0, idx = 0;
     const out = [];
@@ -1069,10 +1061,7 @@ async function renderSplit(diff, language, max = MAX_PREVIEW_LINES, dc = DEFAULT
             rightSrc.push(r.right.content);
     }
     const [leftHL, rightHL] = canHL
-        ? await Promise.all([
-            hlBlock(leftSrc.join("\n"), language),
-            hlBlock(rightSrc.join("\n"), language),
-        ])
+        ? await Promise.all([hlBlock(leftSrc.join("\n"), language), hlBlock(rightSrc.join("\n"), language)])
         : [leftSrc, rightSrc];
     let lI = 0, rI = 0;
     let stripeRow = 0; // tracks row index for diagonal stripe offset
@@ -1094,13 +1083,7 @@ async function renderSplit(diff, language, max = MAX_PREVIEW_LINES, dc = DEFAULT
         const cBg = isDel ? BG_DEL : isAdd ? BG_ADD : BG_BASE;
         const sFg = isDel ? dc.fgDel : isAdd ? dc.fgAdd : dc.fgCtx;
         const sign = isDel ? "-" : isAdd ? "+" : " ";
-        const num = isDel
-            ? line.oldNum
-            : isAdd
-                ? line.newNum
-                : side === "left"
-                    ? line.oldNum
-                    : line.newNum;
+        const num = isDel ? line.oldNum : isAdd ? line.newNum : side === "left" ? line.oldNum : line.newNum;
         // Border bar + colored line numbers for changed lines
         const borderFg = isDel ? dc.fgDel : isAdd ? dc.fgAdd : "";
         const border = borderFg ? `${borderFg}${getBorderBar()}${RST}` : `${BG_BASE}`;
@@ -1217,31 +1200,20 @@ export default async function diffRendererExtension(pi) {
             return;
         writeHeaderStatsByCallId.set(toolCallId, { added, removed });
     }
-    const hashlineEditHeaderStatsByCallId = new Map();
-    function stashHashlineEditHeaderStats(toolCallId, diffLines, added, removed) {
-        if (!toolCallId)
-            return;
-        hashlineEditHeaderStatsByCallId.set(toolCallId, { diffLines, added, removed });
-    }
-    function hashlineEditCallStatsSuffix(toolCallId, theme) {
-        const raw = toolCallId ? hashlineEditHeaderStatsByCallId.get(toolCallId) : undefined;
-        if (!raw)
-            return "";
-        const loc = raw.diffLines > 0
-            ? `${theme.fg("muted", `${raw.diffLines} diff line${raw.diffLines === 1 ? "" : "s"}`)} `
-            : "";
-        return `${TOOL_RESULT_INDENT}${loc}${summarizeThemed(raw.added, raw.removed, theme)}`;
-    }
     const cwd = process.cwd();
     const home = process.env.HOME ?? "";
     const sp = (p) => shortPath(cwd, home, p);
     const TOOL_RESULT_INDENT = " ";
     const TOOL_HEADER_LEFT_PAD = 0;
     const DIFF_BODY_LEFT_PAD = 0;
-    /** Extra frame padding for built-in `edit` tool diff results only. */
-    const EDIT_DIFF_RESULT_FRAME = { headerLeftPad: 1, topPad: 1, bottomPad: 1, previewBottomPad: 1 };
-    /** hashline_read / hashline_edit: one gap under call title (Pi shell only; no formatBottomPadding on call). */
-    const HASHLINE_TOOL_RESULT_FRAME = { previewBottomPad: 0, callTitleBottomPad: 0 };
+    /** Built-in `edit` tool diff result frame; intentionally offset from read/write/apply_patch previews. */
+    const EDIT_DIFF_RESULT_FRAME = {
+        headerLeftPad: 1,
+        bodyLeftPad: 1,
+        topPad: 1,
+        bottomPad: 0,
+        previewBottomPad: 1,
+    };
     function resolvePreviewDiffColors(theme) {
         resolveDiffColors(theme);
         return resolveSharedDiffColors(theme);
@@ -1251,19 +1223,114 @@ export default async function diffRendererExtension(pi) {
         const padding = " ".repeat(Math.max(0, renderWidth - strip(content).length));
         return injectBg(`${content}${padding}`, [], BG_BASE, BG_BASE);
     }
-    function formatToolFrameHeader(opts) {
-        const { width, topPad = 0, bottomPad = 0, headerLeftPad, suffix = "", label, filePath, theme, meta } = opts;
+    function formatToolFrameHeaderText(opts) {
+        const { topPad = 0, bottomPad = 0, headerLeftPad, suffix = "", label, filePath, theme, meta } = opts;
         const leftPad = " ".repeat(headerLeftPad ?? TOOL_HEADER_LEFT_PAD);
-        const content = label !== undefined
-            ? `${leftPad}${theme.fg("toolTitle", theme.bold(label))}${filePath ? ` ${theme.fg("accent", sp(filePath))}` : ""}${suffix}`
-            : `${leftPad}${meta ?? ""}`;
-        const parts = [];
-        for (let i = 0; i < topPad; i++)
-            parts.push(bgLine("", width));
-        parts.push(bgLine(content, width));
-        for (let i = 0; i < bottomPad; i++)
-            parts.push(bgLine("", width));
-        return parts.join("\n");
+        const content = meta !== undefined && meta !== null
+            ? `${leftPad}${meta}${suffix}`
+            : `${leftPad}${theme.fg("toolTitle", theme.bold(label ?? ""))} ${theme.fg("accent", sp(filePath ?? ""))}${suffix}`;
+        return `${"\n".repeat(topPad)}${content}${"\n".repeat(bottomPad)}`;
+    }
+    function formatToolFrameHeader(opts) {
+        const { width, ...rest } = opts;
+        return bgLine(formatToolFrameHeaderText(rest), width);
+    }
+    function setToolHeaderBg(text) {
+        text.customBgFn = (line) => injectBg(line, [], BG_BASE, BG_BASE);
+    }
+    function clearToolHeaderBg(text) {
+        text.customBgFn = undefined;
+    }
+    function summarizeApplyPatchChanges(changes, theme) {
+        const labels = changes.map((change) => theme.fg("accent", sp(change.path)));
+        if (labels.length <= 1)
+            return labels.join("");
+        return `${labels[0]}${theme.fg("muted", `, +${labels.length - 1} more`)}`;
+    }
+    function renderApplyPatchPreview(text, result, theme, ctx) {
+        const applied = Array.isArray(result?.applied) ? result.applied : [];
+        if (!applied.length)
+            return false;
+        const w = termW();
+        const previewable = applied.filter((change) => {
+            if (typeof change?.path !== "string")
+                return false;
+            if (change.action === "add")
+                return typeof change.newContent === "string";
+            if (change.action === "update" || change.action === "delete")
+                return typeof change.oldContent === "string";
+            return false;
+        });
+        if (previewable.length !== applied.length)
+            return false;
+        if (previewable.length === 1) {
+            const change = previewable[0];
+            if (change.action === "add" && typeof change.newContent === "string") {
+                clearToolHeaderBg(text);
+                resolvePreviewDiffColors(theme);
+                const lineCount = change.newContent.split("\n").length;
+                const newHdr = bgLine(`${theme.fg("success", `✓ new file (${lineCount} lines)`)}`, w);
+                const fp = change.path;
+                const pk = `ap:nf:${sharedThemeCacheKey(theme)}:${fp}:${lineCount}`;
+                if (ctx.state._nfk !== pk) {
+                    ctx.state._nfk = pk;
+                    const lg = detectDiffLanguage(fp);
+                    text.__piDiffTask = {
+                        placeholder: `${newHdr}\n${padDiffBody(theme.fg("muted", "rendering file…"))}`,
+                        fallback: `${newHdr}`,
+                        invalidate: ctx.invalidate,
+                        key: (width) => `ap:nf:${sharedThemeCacheKey(theme)}:${fp}:${lineCount}:${width}`,
+                        render: async (_width) => {
+                            const hlLines = await hlBlock(change.newContent, lg);
+                            const preview = hlLines.join("\n").replace(/\n+$/, "");
+                            return `${newHdr}\n${padDiffBody(preview)}`;
+                        },
+                    };
+                }
+                return true;
+            }
+            if ((change.action === "update" || change.action === "delete") &&
+                typeof change.oldContent === "string" &&
+                typeof change.path === "string") {
+                const parsed = parseDiff(change.oldContent, change.newContent ?? "");
+                setDiffPreviewTask(text, "ap", (width) => formatToolFrameHeader({
+                    meta: `${theme.fg("toolTitle", theme.bold("apply_patch"))}${TOOL_RESULT_INDENT}${theme.fg("muted", `(1 change)`)}${TOOL_RESULT_INDENT}${theme.fg("accent", sp(change.path))}`,
+                    theme,
+                    width,
+                    topPad: 0,
+                    bottomPad: 0,
+                }), parsed, detectDiffLanguage(change.path), MAX_PREVIEW_LINES, theme, ctx, { previewBottomPad: 1, compactGutter: true });
+                return true;
+            }
+            return false;
+        }
+        clearToolHeaderBg(text);
+        let added = 0;
+        let removed = 0;
+        let chars = 0;
+        let language;
+        let mixedLanguage = false;
+        const lines = [];
+        for (const change of previewable) {
+            const parsed = parseDiff(change.oldContent ?? "", change.newContent ?? "");
+            const nextLanguage = detectDiffLanguage(change.path);
+            if (!language)
+                language = nextLanguage;
+            else if (language !== nextLanguage)
+                mixedLanguage = true;
+            added += parsed.added;
+            removed += parsed.removed;
+            chars += parsed.chars;
+            lines.push(...parsed.lines);
+        }
+        setDiffPreviewTask(text, "ap", (width) => formatToolFrameHeader({
+            meta: `${theme.fg("toolTitle", theme.bold("apply_patch"))}${TOOL_RESULT_INDENT}${theme.fg("muted", `(${previewable.length} changes)`)} ${summarizeThemed(added, removed, theme)}${TOOL_RESULT_INDENT}${theme.fg("muted", summarizeApplyPatchChanges(previewable, theme))}`,
+            theme,
+            width,
+            topPad: 0,
+            bottomPad: 0,
+        }), { lines, added, removed, chars }, mixedLanguage ? undefined : language, MAX_PREVIEW_LINES, theme, ctx, { previewBottomPad: 1, compactGutter: true });
+        return true;
     }
     function editEditsCountLabel(edits, diffLines, theme) {
         const n = edits === 1 ? "1 edit" : `${edits} edits`;
@@ -1279,9 +1346,7 @@ export default async function diffRendererExtension(pi) {
     function formatEditDiffResultTitle(d, theme, width, frame) {
         const fp = d.filePath ?? d.summary ?? "";
         const edits = d.edits ?? d.editCount ?? 1;
-        const diffLines = typeof d.diffLineCount === "number"
-            ? d.diffLineCount
-            : (d.linesAdded ?? 0) + (d.linesRemoved ?? 0);
+        const diffLines = typeof d.diffLineCount === "number" ? d.diffLineCount : (d.linesAdded ?? 0) + (d.linesRemoved ?? 0);
         const suffix = `${TOOL_RESULT_INDENT}${theme.fg("muted", editEditsCountLabel(edits, diffLines, theme))} ${summarizeThemed(d.linesAdded ?? 0, d.linesRemoved ?? 0, theme)}`;
         return formatToolFrameHeader({
             width,
@@ -1300,16 +1365,20 @@ export default async function diffRendererExtension(pi) {
             return "";
         return `${TOOL_RESULT_INDENT}${summarizeThemed(raw.added, raw.removed, theme)}`;
     }
-    function padDiffBody(rendered) {
-        const leftPad = `${BG_BASE}${" ".repeat(DIFF_BODY_LEFT_PAD)}${RST}`;
+    function padDiffBody(rendered, bodyLeftPad = DIFF_BODY_LEFT_PAD) {
+        const leftPad = `${BG_BASE}${" ".repeat(bodyLeftPad)}${RST}`;
         return rendered
             .split("\n")
             .map((line) => `${leftPad}${line}`)
             .join("\n");
     }
-    async function renderPaddedDiff(diff, language, maxLines, colors, width) {
-        const bodyWidth = Math.max(1, width - DIFF_BODY_LEFT_PAD);
-        return padDiffBody(await renderSharedSplit(diff, language, maxLines, colors, bodyWidth));
+    async function renderPaddedDiff(diff, language, maxLines, colors, width, bodyLeftPad = DIFF_BODY_LEFT_PAD) {
+        const bodyWidth = Math.max(1, width - bodyLeftPad);
+        return padDiffBody(await renderSharedSplit(diff, language, maxLines, colors, bodyWidth), bodyLeftPad);
+    }
+    async function renderPaddedCompactDiff(diff, language, maxLines, colors, width, bodyLeftPad = DIFF_BODY_LEFT_PAD) {
+        const bodyWidth = Math.max(1, width - bodyLeftPad);
+        return padDiffBody(await renderSharedSplit(diff, language, maxLines, colors, bodyWidth, { compactGutter: true }), bodyLeftPad);
     }
     function diffLineCountLabel(diffLineCount, theme) {
         if (typeof diffLineCount !== "number")
@@ -1319,13 +1388,13 @@ export default async function diffRendererExtension(pi) {
     function setToolHeaderText(text, meta, theme) {
         resolvePreviewDiffColors(theme);
         text.__piDiffTask = undefined;
-        const width = termW();
-        text.setText(formatToolFrameHeader({ meta, width, bottomPad: 0 }));
+        setToolHeaderBg(text);
+        text.setText(formatToolFrameHeaderText({ meta, bottomPad: 0 }));
     }
     function setDiffPreviewTask(text, keyPrefix, metaOrHeader, diff, language, maxLines, theme, ctx, frame) {
+        clearToolHeaderBg(text);
         const themeKey = sharedThemeCacheKey(theme);
         const colors = resolvePreviewDiffColors(theme);
-        const headerKey = typeof metaOrHeader === "function" ? "fn:" + keyPrefix : metaOrHeader;
         const header = frame?.omitHeader
             ? (_width) => ""
             : typeof metaOrHeader === "function"
@@ -1345,11 +1414,16 @@ export default async function diffRendererExtension(pi) {
             return bottom ? `${main}\n${bottom}` : main;
         };
         text.__piDiffTask = {
-            placeholder: joinHeaderBody(termW(), padDiffBody(theme.fg("muted", " rendering diff…"))),
+            placeholder: joinHeaderBody(termW(), padDiffBody(theme.fg("muted", " rendering diff…"), frame?.bodyLeftPad)),
             fallback: header(termW()),
             invalidate: ctx.invalidate,
-            key: (width) => `${keyPrefix}:${themeKey}:${width}:${headerKey}:${diff.lines.length}:${language ?? ""}:${frame?.omitHeader ? "oh" : "h"}:${frame?.previewBottomPad ?? 0}`,
-            render: async (width) => joinHeaderBody(width, await renderPaddedDiff(diff, language, maxLines, colors, width)),
+            key: (width) => {
+                const headerKey = frame?.omitHeader ? "" : header(width);
+                return `${keyPrefix}:${themeKey}:${width}:${headerKey}:${diff.lines.length}:${language ?? ""}:${frame?.omitHeader ? "oh" : "h"}:${frame?.headerLeftPad ?? 0}:${frame?.topPad ?? 0}:${frame?.bottomPad ?? 0}:${frame?.previewBottomPad ?? 0}:${frame?.compactGutter ? "cg" : "rg"}:${frame?.bodyLeftPad ?? 0}`;
+            },
+            render: async (width) => joinHeaderBody(width, await (frame?.compactGutter
+                ? renderPaddedCompactDiff(diff, language, maxLines, colors, width, frame?.bodyLeftPad)
+                : renderPaddedDiff(diff, language, maxLines, colors, width, frame?.bodyLeftPad))),
         };
     }
     /** Wrap a Text component so its render(width) kicks off async diff rendering
@@ -1450,7 +1524,8 @@ export default async function diffRendererExtension(pi) {
             if (args?.content && !ctx.argsComplete) {
                 const n = String(args.content).split("\n").length;
                 const suffix = `${TOOL_RESULT_INDENT}${theme.fg("muted", `(${n} lines…)`)}${stats ? ` ${stats.trimStart()}` : ""}`;
-                text.setText(formatToolFrameHeader({ label, filePath: fp, theme, width: w, suffix, topPad: 0, bottomPad: 0 }));
+                setToolHeaderBg(text);
+                text.setText(formatToolFrameHeaderText({ label, filePath: fp, theme, suffix, topPad: 0, bottomPad: 0 }));
                 return text;
             }
             if (args?.content && ctx.argsComplete && isNew) {
@@ -1469,10 +1544,12 @@ export default async function diffRendererExtension(pi) {
                     })
                         .catch(() => { });
                 }
+                clearToolHeaderBg(text);
                 text.setText(ctx.state._previewText ?? title);
                 return text;
             }
-            text.setText(formatToolFrameHeader({ label, filePath: fp, theme, width: w, suffix: stats, topPad: 0, bottomPad: 0 }));
+            setToolHeaderBg(text);
+            text.setText(formatToolFrameHeaderText({ label, filePath: fp, theme, suffix: stats, topPad: 0, bottomPad: 0 }));
             return text;
         },
         renderResult(result, _opt, theme, ctx) {
@@ -1483,21 +1560,28 @@ export default async function diffRendererExtension(pi) {
                     .map((c) => c.text || "")
                     .join("\n") ?? "Error";
                 text.__piDiffTask = undefined;
+                clearToolHeaderBg(text);
                 text.setText(`\n${theme.fg("error", e)}`);
                 return text;
             }
             const d = result.details;
             if (d?._type === "diff") {
-                setDiffPreviewTask(text, "wd", "", d.diff, d.language, MAX_RENDER_LINES, theme, ctx, { omitHeader: true, previewBottomPad: 1 });
+                setDiffPreviewTask(text, "wd", "", d.diff, d.language, MAX_RENDER_LINES, theme, ctx, {
+                    omitHeader: true,
+                    previewBottomPad: 1,
+                    compactGutter: true,
+                });
                 return text;
             }
             if (d?._type === "noChange") {
                 text.__piDiffTask = undefined;
+                clearToolHeaderBg(text);
                 text.setText(`${TOOL_RESULT_INDENT}${theme.fg("muted", "✓ no changes")}`);
                 return text;
             }
             if (d?._type === "new") {
                 const { lines: lineCount, content: rawContent, filePath: fp } = d;
+                clearToolHeaderBg(text);
                 resolvePreviewDiffColors(theme);
                 const w = termW();
                 const newHdr = bgLine(`${theme.fg("success", `✓ new file (${lineCount} lines)`)}`, w);
@@ -1517,15 +1601,14 @@ export default async function diffRendererExtension(pi) {
                             const maxShow = hlLines.length;
                             const preview = hlLines.slice(0, maxShow).join("\n").replace(/\n+$/, "");
                             const rem = hlLines.length - maxShow;
-                            const moreLine = rem > 0
-                                ? `\n${bgLine(`${TOOL_RESULT_INDENT}${theme.fg("muted", `… ${rem} more lines`)}`, width)}`
-                                : "";
+                            const moreLine = rem > 0 ? `\n${bgLine(`${TOOL_RESULT_INDENT}${theme.fg("muted", `… ${rem} more lines`)}`, width)}` : "";
                             return `${newHdr}\n${padDiffBody(preview)}${moreLine}`;
                         },
                     };
                 }
                 return text;
             }
+            clearToolHeaderBg(text);
             text.setText(`${TOOL_RESULT_INDENT}${theme.fg("dim", String(result?.content?.[0]?.text ?? "written").slice(0, 120))}`);
             return text;
         },
@@ -1538,29 +1621,13 @@ export default async function diffRendererExtension(pi) {
         if (Array.isArray(input?.edits)) {
             return input.edits
                 .map((edit) => ({
-                oldText: typeof edit?.oldText === "string"
-                    ? edit.oldText
-                    : typeof edit?.old_text === "string"
-                        ? edit.old_text
-                        : "",
-                newText: typeof edit?.newText === "string"
-                    ? edit.newText
-                    : typeof edit?.new_text === "string"
-                        ? edit.new_text
-                        : "",
+                oldText: typeof edit?.oldText === "string" ? edit.oldText : typeof edit?.old_text === "string" ? edit.old_text : "",
+                newText: typeof edit?.newText === "string" ? edit.newText : typeof edit?.new_text === "string" ? edit.new_text : "",
             }))
                 .filter((edit) => edit.oldText && edit.oldText !== edit.newText);
         }
-        const oldText = typeof input?.oldText === "string"
-            ? input.oldText
-            : typeof input?.old_text === "string"
-                ? input.old_text
-                : "";
-        const newText = typeof input?.newText === "string"
-            ? input.newText
-            : typeof input?.new_text === "string"
-                ? input.new_text
-                : "";
+        const oldText = typeof input?.oldText === "string" ? input.oldText : typeof input?.old_text === "string" ? input.old_text : "";
+        const newText = typeof input?.newText === "string" ? input.newText : typeof input?.new_text === "string" ? input.new_text : "";
         return oldText && oldText !== newText ? [{ oldText, newText }] : [];
     }
     function summarizeEditOperations(operations) {
@@ -1580,57 +1647,21 @@ export default async function diffRendererExtension(pi) {
         parameters: {
             ...(origEdit.parameters || {}),
             properties: {
-                ...(((origEdit.parameters || {}).properties) || {}),
-                dryRun: {
-                    type: "boolean",
-                    description: "With hashlineChanges: validate anchors and return diff without writing (same as hashline_edit dryRun).",
+                ...(origEdit.parameters?.properties || {}),
+                oldText: {
+                    type: "string",
+                    description: "Exact existing text to replace.",
                 },
-                hashlineChanges: {
-                    type: "array",
-                    description: "Hashline-anchored edits. Each entry: { hash_range_inclusive: [start, end], content_lines: string[] }. Preferred over oldString/newString — no fuzzy matching, no stale-view risk.",
-                    items: {
-                        type: "object",
-                        properties: {
-                            hash_range_inclusive: {
-                                type: "array",
-                                items: { type: "string" },
-                                minItems: 2,
-                                maxItems: 2,
-                                description: "[start_anchor, end_anchor] from a prior hashline_read. Use identical anchor for a single-line edit.",
-                            },
-                            content_lines: {
-                                type: "array",
-                                items: { type: "string" },
-                                description: "Replacement lines. Pass an empty array to delete the range.",
-                            },
-                        },
-                        required: ["hash_range_inclusive", "content_lines"],
-                        additionalProperties: false,
-                    },
+                newText: {
+                    type: "string",
+                    description: "Replacement text for oldText.",
                 },
             },
+            required: ["path"],
+            additionalProperties: true,
         },
         async execute(tid, params, sig, upd, ctx) {
             const fp = params.path ?? params.file_path ?? "";
-            // Hashline path: strict, no fuzzy fallback, atomic write.
-            // If the model uses hashlineChanges, route exclusively here. Otherwise fall through
-            // to the legacy 6-strategy oldString/newString path below.
-            if (Array.isArray(params.hashlineChanges) && params.hashlineChanges.length > 0) {
-                if (!fp) {
-                    return {
-                        content: [{ type: "text", text: "[E_BAD_INPUT] path required for hashlineChanges" }],
-                        isError: true,
-                    };
-                }
-                const resolvedFp = resolve(cwd, fp);
-                return runHashlineEdit({
-                    resolvedPath: resolvedFp,
-                    changes: params.hashlineChanges,
-                    dryRun: params.dryRun === true,
-                    toolCallId: tid,
-                    onDiffStats: (id, diff) => stashHashlineEditHeaderStats(id, diff.lines.length, diff.added, diff.removed),
-                });
-            }
             const operations = getEditOperations(params);
             // Try cascading replace() first — smarter matching than SDK's exact-only edit
             if (fp && operations.length > 0 && existsSync(fp)) {
@@ -1665,9 +1696,7 @@ export default async function diffRendererExtension(pi) {
                                 editLine = 0;
                             }
                             const useFull = !!params._expandGaps;
-                            const diffData = useFull
-                                ? parseDiff(operations[0].oldText, operations[0].newText, undefined)
-                                : diffs[0];
+                            const diffData = useFull ? parseDiff(operations[0].oldText, operations[0].newText, undefined) : diffs[0];
                             return {
                                 content: [{ type: "text", text: `Edited ${sp(fp)}` }],
                                 details: {
@@ -1749,9 +1778,7 @@ export default async function diffRendererExtension(pi) {
                     editLine = 0;
                 }
                 const useFull = !!params._expandGaps;
-                const diffData = useFull
-                    ? parseDiff(operations[0].oldText, operations[0].newText, undefined)
-                    : diffs[0];
+                const diffData = useFull ? parseDiff(operations[0].oldText, operations[0].newText, undefined) : diffs[0];
                 result.details = {
                     _type: "editInfo",
                     summary: editLine > 0 ? `${summary} at line ${editLine}` : summary,
@@ -1826,13 +1853,13 @@ export default async function diffRendererExtension(pi) {
                 catch {
                     previewLine = 0;
                 }
-                const loc = previewLine > 0 ? ` ${theme.fg("muted", `at line ${previewLine}`)}` : "";
-                text.setText(formatToolFrameHeader({
+                const loc = previewLine > 0 ? `${TOOL_RESULT_INDENT}${theme.fg("muted", `at line ${previewLine}`)}` : "";
+                setToolHeaderBg(text);
+                text.setText(formatToolFrameHeaderText({
                     label: "edit",
                     filePath: fp,
                     theme,
-                    width: termW(),
-                    suffix: `${stats}${loc}`,
+                    suffix: loc,
                     topPad: EDIT_DIFF_RESULT_FRAME.topPad,
                     bottomPad: EDIT_DIFF_RESULT_FRAME.bottomPad,
                     headerLeftPad: EDIT_DIFF_RESULT_FRAME.headerLeftPad,
@@ -1865,17 +1892,23 @@ export default async function diffRendererExtension(pi) {
             }
             const d = result.details;
             if (d?._type === "editInfo" && d.diff) {
-                setDiffPreviewTask(text, "ed", "", d.diff, d.language, MAX_PREVIEW_LINES, theme, ctx, { omitHeader: true, previewBottomPad: EDIT_DIFF_RESULT_FRAME.previewBottomPad });
-                return text;
-            }
-            if ((d?._type === "hashlineEditInfo" || d?._type === "hashlineEditDryRun") && d.diff) {
-                setDiffPreviewTask(text, d.path, "", d.diff, undefined, MAX_PREVIEW_LINES, theme, ctx, { omitHeader: true, previewBottomPad: EDIT_DIFF_RESULT_FRAME.previewBottomPad });
+                setDiffPreviewTask(text, "ed", "", d.diff, d.language, MAX_PREVIEW_LINES, theme, ctx, {
+                    omitHeader: true,
+                    previewBottomPad: EDIT_DIFF_RESULT_FRAME.previewBottomPad,
+                    compactGutter: true,
+                    bodyLeftPad: EDIT_DIFF_RESULT_FRAME.bodyLeftPad,
+                });
                 return text;
             }
             if (d?._type === "multiEditInfo") {
                 const { editCount, diffLineCount, diff, language } = d;
                 if (diff) {
-                    setDiffPreviewTask(text, "me", "", diff, language, MAX_PREVIEW_LINES, theme, ctx, { omitHeader: true, previewBottomPad: EDIT_DIFF_RESULT_FRAME.previewBottomPad });
+                    setDiffPreviewTask(text, "me", "", diff, language, MAX_PREVIEW_LINES, theme, ctx, {
+                        omitHeader: true,
+                        previewBottomPad: EDIT_DIFF_RESULT_FRAME.previewBottomPad,
+                        compactGutter: true,
+                        bodyLeftPad: EDIT_DIFF_RESULT_FRAME.bodyLeftPad,
+                    });
                     return text;
                 }
                 const meta = `${editCount} edits${diffLineCountLabel(diffLineCount, theme)}`;
@@ -1883,172 +1916,94 @@ export default async function diffRendererExtension(pi) {
                 return text;
             }
             text.__piDiffTask = undefined;
+            clearToolHeaderBg(text);
             text.setText(`${TOOL_RESULT_INDENT}${theme.fg("dim", String(result?.content?.[0]?.text ?? "edited").slice(0, 120))}`);
             return text;
         },
     });
-    // Eager-init the hashline engine on session start so first edit has no WASM latency.
-    pi.on("session_start", async () => {
-        try {
-            await initHashline();
-        }
-        catch {
-            // best-effort; lazy init still works on first edit
-        }
-    });
     pi.registerTool({
-        name: "hashline_read",
-        label: "hashline_read",
-        description: HASHLINE_READ_DESC,
+        name: "apply_patch",
+        label: "apply_patch",
+        description: "Multi-file patch engine. One call can add, update, delete, or move multiple files. Uses structured JSON changes array.",
         parameters: {
             type: "object",
             properties: {
-                path: { type: "string", description: "Absolute or relative file path" },
-                startLine: { type: "number", description: "Optional 1-indexed start line" },
-                endLine: { type: "number", description: "Optional 1-indexed end line (inclusive)" },
-            },
-            required: ["path"],
-            additionalProperties: false,
-        },
-        renderCall(args, theme, ctx) {
-            const fp = args?.path ?? "";
-            const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
-            resolvePreviewDiffColors(theme);
-            const range = typeof args?.startLine === "number" || typeof args?.endLine === "number"
-                ? ` ${theme.fg("muted", `lines ${args.startLine ?? 1}-${args.endLine ?? "…"}`)}`
-                : "";
-            text.setText(formatToolFrameHeader({
-                label: "hashline_read",
-                filePath: fp,
-                theme,
-                width: termW(),
-                suffix: range,
-                topPad: 0,
-                bottomPad: HASHLINE_TOOL_RESULT_FRAME.callTitleBottomPad,
-            }));
-            return text;
-        },
-        async execute(_tid, params) {
-            await initHashline();
-            const fp = resolve(cwd, params.path);
-            if (!fp) {
-                return { content: [{ type: "text", text: "[E_BAD_INPUT] path required" }], isError: true, details: {} };
-            }
-            let content;
-            try {
-                content = await fs.promises.readFile(fp, "utf8");
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return {
-                    content: [{ type: "text", text: `[E_READ_FAILED] cannot read ${fp}: ${msg}` }],
-                    isError: true,
-                    details: {},
-                };
-            }
-            const startLine = typeof params.startLine === "number" ? Math.max(1, params.startLine) : 1;
-            const endLine = typeof params.endLine === "number" ? Math.max(startLine, params.endLine) : Infinity;
-            return executeHashlineRead(fp, content, startLine, endLine);
-        },
-        renderResult(result, _opt, theme, ctx) {
-            const text = getWidthAwareText(ctx.lastComponent);
-            const d = result.details;
-            const lineCount = d?.lineCount ?? 0;
-            if (ctx.expanded === false) {
-                text.__piDiffTask = undefined;
-                const hint = theme.fg("dim", `(${lineCount} lines)  ctrl+o to expand`);
-                text.setText(hint);
-                return text;
-            }
-            text.__piDiffTask = undefined;
-            const out = (result.content || []).map((c) => c.text).join("\n");
-            text.setText(out);
-            return text;
-        },
-    });
-    pi.registerTool({
-        name: "hashline_edit",
-        label: "hashline_edit",
-        description: HASHLINE_EDIT_DESC,
-        parameters: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Absolute or relative file path" },
-                dryRun: {
-                    type: "boolean",
-                    description: "If true, validate anchors and return diff without writing the file.",
-                },
-                hashlineChanges: {
+                changes: {
                     type: "array",
-                    description: "Atomic list of range replacements (empty content_lines deletes the range).",
+                    description: "Array of file changes to apply atomically.",
                     items: {
                         type: "object",
                         properties: {
-                            hash_range_inclusive: {
-                                type: "array",
-                                description: "[start_anchor, end_anchor] from hashline_read (LINE│HASH│content).",
-                                items: { type: "string" },
-                                minItems: 2,
-                                maxItems: 2,
-                            },
-                            content_lines: {
-                                type: "array",
-                                description: "Replacement lines; use [] to delete the anchored range.",
-                                items: { type: "string" },
+                            path: { type: "string", description: "Absolute path to the file." },
+                            action: {
+                                type: "string",
+                                enum: ["add", "update", "delete", "move"],
+                                description: "The operation to perform.",
                             },
+                            content: { type: "string", description: "Content for new files (action=add)." },
+                            oldText: { type: "string", description: "Text to find for updates (action=update)." },
+                            newText: { type: "string", description: "Replacement text for updates (action=update)." },
+                            movePath: { type: "string", description: "Destination path for moves (action=move)." },
                         },
-                        required: ["hash_range_inclusive", "content_lines"],
-                        additionalProperties: false,
+                        required: ["path", "action"],
                     },
                 },
             },
-            required: ["path", "hashlineChanges"],
-            additionalProperties: false,
+            required: ["changes"],
+        },
+        async execute(_tid, params) {
+            const changes = (params.changes ?? []).map((c) => ({
+                path: c.path,
+                action: c.action,
+                content: c.content,
+                oldText: c.oldText,
+                newText: c.newText,
+                movePath: c.movePath,
+            }));
+            const result = await executeApplyPatch(changes);
+            const output = formatApplyPatchResult(result);
+            return {
+                content: [{ type: "text", text: output }],
+                isError: !result.ok,
+                details: { _type: "applyPatchInfo", result },
+            };
         },
         renderCall(args, theme, ctx) {
-            const fp = args?.path ?? "";
-            const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
-            resolvePreviewDiffColors(theme);
-            const stats = hashlineEditCallStatsSuffix(ctx.toolCallId, theme);
-            text.setText(formatToolFrameHeader({
-                label: "hashline_edit",
-                filePath: fp,
-                theme,
-                width: termW(),
-                suffix: stats,
+            const text = getWidthAwareText(ctx.lastComponent);
+            const changes = Array.isArray(args?.changes) ? args.changes : [];
+            const count = changes.length;
+            if (ctx.argsComplete && count > 0) {
+                clearToolHeaderBg(text);
+                text.setText("");
+                return text;
+            }
+            const suffix = count
+                ? `${TOOL_RESULT_INDENT}${theme.fg("muted", `(${count} change${count === 1 ? "" : "s"})`)}${TOOL_RESULT_INDENT}${summarizeApplyPatchChanges(changes, theme)}`
+                : `${TOOL_RESULT_INDENT}${theme.fg("muted", "(waiting for changes)")}`;
+            setToolHeaderBg(text);
+            text.setText(formatToolFrameHeaderText({
+                meta: `${theme.fg("toolTitle", theme.bold("apply_patch"))}${suffix}`,
                 topPad: 0,
-                bottomPad: HASHLINE_TOOL_RESULT_FRAME.callTitleBottomPad,
+                bottomPad: 0,
             }));
             return text;
         },
-        async execute(tid, params) {
-            await initHashline();
-            const fp = resolve(cwd, params.path);
-            if (!fp) {
-                return { content: [{ type: "text", text: "[E_BAD_INPUT] path required" }], isError: true, details: {} };
-            }
-            if (!Array.isArray(params.hashlineChanges) || params.hashlineChanges.length === 0) {
-                return { content: [{ type: "text", text: "[E_EMPTY] hashlineChanges must be a non-empty array" }], isError: true, details: {} };
-            }
-            return runHashlineEdit({
-                resolvedPath: fp,
-                changes: params.hashlineChanges,
-                dryRun: params.dryRun === true,
-                toolCallId: tid,
-                onDiffStats: (id, diff) => stashHashlineEditHeaderStats(id, diff.lines.length, diff.added, diff.removed),
-            });
-        },
         renderResult(result, _opt, theme, ctx) {
             const text = getWidthAwareText(ctx.lastComponent);
-            const d = result.details;
-            if ((d?._type === "hashlineEditInfo" || d?._type === "hashlineEditDryRun") && d.diff) {
-                setDiffPreviewTask(text, "he", "", d.diff, undefined, MAX_RENDER_LINES, theme, ctx, { omitHeader: true, previewBottomPad: HASHLINE_TOOL_RESULT_FRAME.previewBottomPad });
+            if (ctx.isError) {
+                const out = (result.content || []).map((c) => c.text).join("\n") || "Error";
+                text.__piDiffTask = undefined;
+                clearToolHeaderBg(text);
+                text.setText(theme.fg("error", out));
                 return text;
             }
-            // Fallback for errors / no-diff
-            text.__piDiffTask = undefined;
+            const patchResult = result.details?.result;
+            if (renderApplyPatchPreview(text, patchResult, theme, ctx))
+                return text;
             const out = (result.content || []).map((c) => c.text).join("\n");
-            text.setText(theme.fg(ctx.isError ? "error" : "muted", out));
+            text.__piDiffTask = undefined;
+            clearToolHeaderBg(text);
+            text.setText(theme.fg("muted", out));
             return text;
         },
     });