@heyhuynhgiabuu/pi-diff 0.6.10 → 0.7.1

package/dist/index.js

@@ -21,13 +21,16 @@
  *   • Async rendering with invalidate() for non-blocking preview
  */
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { extname, relative } from "node:path";
+import { extname, relative, resolve } from "node:path";
 import { codeToANSI } from "@shikijs/cli";
 import * as Diff from "diff";
 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: {
@@ -930,7 +933,7 @@ async function renderUnified(diff, language, max = MAX_RENDER_LINES, dc = DEFAUL
     /** Emit a single stacked row with compact gutter + left border bar. */
     function emitRow(num, sign, gutterBg, signFg, body, bodyBg = "") {
         const borderFg = sign === "-" ? dc.fgDel : sign === "+" ? dc.fgAdd : "";
-        const border = borderFg ? `${borderFg}${getBorderBar()}${RST}` : `${BG_BASE} `;
+        const border = borderFg ? `${borderFg}${getBorderBar()}${RST}` : `${BG_BASE}`;
         const numFg = borderFg || FG_LNUM;
         const gutter = `${border}${gutterBg}${lnum(num, nw, numFg)}${gutterBg} ${signFg}${sign}${gutterBg} ${RST}`;
         const contGutter = `${border}${gutterBg}${" ".repeat(nw + 3)}${RST}`;
@@ -1083,7 +1086,7 @@ async function renderSplit(diff, language, max = MAX_PREVIEW_LINES, dc = DEFAULT
             const label = sepLabelSplit(getSepStyle(), line.hunkMeta, line.newNum, line.content);
             if (!label)
                 return { gutter: "", contGutter: "", bodyRows: [""] };
-            const g = `${BG_BASE} ${FG_DIM}${fit("", nw + 3)}${RST}`;
+            const g = `${BG_BASE}${FG_DIM}${fit("", nw + 3)}${RST}`;
             return { gutter: g, contGutter: g, bodyRows: [`${BG_BASE}${FG_DIM}${fit(label, cw)}${RST}`] };
         }
         const isDel = line.type === "del", isAdd = line.type === "add";
@@ -1100,7 +1103,7 @@ async function renderSplit(diff, language, max = MAX_PREVIEW_LINES, dc = DEFAULT
                     : 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}`;
+        const border = borderFg ? `${borderFg}${getBorderBar()}${RST}` : `${BG_BASE}`;
         const numFg = borderFg || FG_LNUM;
         let body;
         if (ranges && ranges.length > 0) {
@@ -1214,14 +1217,31 @@ 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 = 1;
-    const TOOL_HEADER_TOP_PAD = 1;
-    const TOOL_PREVIEW_BOTTOM_PAD = 1;
+    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 };
     function resolvePreviewDiffColors(theme) {
         resolveDiffColors(theme);
         return resolveSharedDiffColors(theme);
@@ -1231,25 +1251,19 @@ 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 formatToolHeader(summary, width) {
-        const leftPad = " ".repeat(TOOL_HEADER_LEFT_PAD);
-        const meta = `${leftPad}${summary}`;
-        return bgLine(meta, width);
-    }
-    function formatToolTitle(label, filePath, theme, width, suffix = "") {
-        const leftPad = " ".repeat(TOOL_HEADER_LEFT_PAD);
-        const displayPath = filePath ? ` ${theme.fg("accent", sp(filePath))}` : "";
-        const top = Array.from({ length: TOOL_HEADER_TOP_PAD }, () => bgLine("", width));
-        return [
-            ...top,
-            bgLine(`${leftPad}${theme.fg("toolTitle", theme.bold(label))}${displayPath}${suffix}`, width),
-        ].join("\n");
-    }
-    function formatBottomPadding(width) {
-        return Array.from({ length: TOOL_PREVIEW_BOTTOM_PAD }, () => bgLine("", width)).join("\n");
-    }
-    function formatToolCallHeader(label, filePath, theme, width, suffix = "") {
-        return [formatToolTitle(label, filePath, theme, width, suffix), formatBottomPadding(width)].join("\n");
+    function formatToolFrameHeader(opts) {
+        const { width, 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");
     }
     function editEditsCountLabel(edits, diffLines, theme) {
         const n = edits === 1 ? "1 edit" : `${edits} edits`;
@@ -1262,6 +1276,24 @@ export default async function diffRendererExtension(pi) {
         const count = editEditsCountLabel(raw.edits, raw.diffLines, theme);
         return `${TOOL_RESULT_INDENT}${theme.fg("muted", count)} ${summarizeThemed(raw.added, raw.removed, theme)}`;
     }
+    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 suffix = `${TOOL_RESULT_INDENT}${theme.fg("muted", editEditsCountLabel(edits, diffLines, theme))} ${summarizeThemed(d.linesAdded ?? 0, d.linesRemoved ?? 0, theme)}`;
+        return formatToolFrameHeader({
+            width,
+            label: "edit",
+            filePath: fp,
+            suffix,
+            theme,
+            topPad: frame.topPad ?? 0,
+            bottomPad: frame.bottomPad ?? 0,
+            headerLeftPad: frame.headerLeftPad,
+        });
+    }
     function writeCallStatsSuffix(toolCallId, theme) {
         const raw = toolCallId ? writeHeaderStatsByCallId.get(toolCallId) : undefined;
         if (!raw)
@@ -1288,18 +1320,36 @@ export default async function diffRendererExtension(pi) {
         resolvePreviewDiffColors(theme);
         text.__piDiffTask = undefined;
         const width = termW();
-        text.setText(`${formatToolHeader(meta, width)}\n${formatBottomPadding(width)}`);
+        text.setText(formatToolFrameHeader({ meta, width, bottomPad: 0 }));
     }
-    function setDiffPreviewTask(text, keyPrefix, meta, diff, language, maxLines, theme, ctx) {
+    function setDiffPreviewTask(text, keyPrefix, metaOrHeader, diff, language, maxLines, theme, ctx, frame) {
         const themeKey = sharedThemeCacheKey(theme);
         const colors = resolvePreviewDiffColors(theme);
-        const header = (width) => formatToolHeader(meta, width);
+        const headerKey = typeof metaOrHeader === "function" ? "fn:" + keyPrefix : metaOrHeader;
+        const header = frame?.omitHeader
+            ? (_width) => ""
+            : typeof metaOrHeader === "function"
+                ? metaOrHeader
+                : (width) => formatToolFrameHeader({
+                    meta: metaOrHeader,
+                    width,
+                    topPad: frame?.topPad ?? 0,
+                    bottomPad: frame?.bottomPad ?? 0,
+                    headerLeftPad: frame?.headerLeftPad,
+                });
+        const joinHeaderBody = (width, body) => {
+            const h = header(width);
+            const bottomPad = Math.max(0, frame?.previewBottomPad ?? 0);
+            const bottom = Array.from({ length: bottomPad }, () => bgLine("", width)).join("\n");
+            const main = h ? `${h}\n${body}` : body;
+            return bottom ? `${main}\n${bottom}` : main;
+        };
         text.__piDiffTask = {
-            placeholder: `${header(termW())}\n${padDiffBody(theme.fg("muted", "rendering diff…"))}\n${formatBottomPadding(termW())}`,
-            fallback: `${header(termW())}\n${formatBottomPadding(termW())}`,
+            placeholder: joinHeaderBody(termW(), padDiffBody(theme.fg("muted", " rendering diff…"))),
+            fallback: header(termW()),
             invalidate: ctx.invalidate,
-            key: (width) => `${keyPrefix}:${themeKey}:${width}:${meta}:${diff.lines.length}:${language ?? ""}`,
-            render: async (width) => `${header(width)}\n${await renderPaddedDiff(diff, language, maxLines, colors, width)}\n${formatBottomPadding(width)}`,
+            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)),
         };
     }
     /** Wrap a Text component so its render(width) kicks off async diff rendering
@@ -1400,11 +1450,11 @@ 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(formatToolCallHeader(label, fp, theme, w, suffix));
+                text.setText(formatToolFrameHeader({ label, filePath: fp, theme, width: w, suffix, topPad: 0, bottomPad: 0 }));
                 return text;
             }
             if (args?.content && ctx.argsComplete && isNew) {
-                const title = formatToolCallHeader(label, fp, theme, w);
+                const title = formatToolFrameHeader({ label, filePath: fp, theme, width: w, topPad: 0, bottomPad: 0 });
                 const previewKey = `create:${sharedThemeCacheKey(theme)}:${fp}:${String(args.content).length}`;
                 if (ctx.state._previewKey !== previewKey) {
                     ctx.state._previewKey = previewKey;
@@ -1422,7 +1472,7 @@ export default async function diffRendererExtension(pi) {
                 text.setText(ctx.state._previewText ?? title);
                 return text;
             }
-            text.setText(formatToolCallHeader(label, fp, theme, w, stats));
+            text.setText(formatToolFrameHeader({ label, filePath: fp, theme, width: w, suffix: stats, topPad: 0, bottomPad: 0 }));
             return text;
         },
         renderResult(result, _opt, theme, ctx) {
@@ -1438,7 +1488,7 @@ export default async function diffRendererExtension(pi) {
             }
             const d = result.details;
             if (d?._type === "diff") {
-                setDiffPreviewTask(text, "wd", "", d.diff, d.language, MAX_RENDER_LINES, theme, ctx);
+                setDiffPreviewTask(text, "wd", "", d.diff, d.language, MAX_RENDER_LINES, theme, ctx, { omitHeader: true, previewBottomPad: 1 });
                 return text;
             }
             if (d?._type === "noChange") {
@@ -1448,31 +1498,32 @@ export default async function diffRendererExtension(pi) {
             }
             if (d?._type === "new") {
                 const { lines: lineCount, content: rawContent, filePath: fp } = d;
+                resolvePreviewDiffColors(theme);
                 const w = termW();
                 const newHdr = bgLine(`${theme.fg("success", `✓ new file (${lineCount} lines)`)}`, w);
                 const pk = `nf:${sharedThemeCacheKey(theme)}:${fp}:${lineCount}`;
                 if (ctx.state._nfk !== pk) {
                     ctx.state._nfk = pk;
-                    ctx.state._nft = newHdr;
                     const lg = detectDiffLanguage(fp);
-                    if (rawContent) {
-                        hlBlock(rawContent, lg)
-                            .then((hlLines) => {
-                            if (ctx.state._nfk !== pk)
-                                return;
+                    text.__piDiffTask = {
+                        placeholder: `${newHdr}\n${padDiffBody(theme.fg("muted", "rendering file…"))}`,
+                        fallback: `${newHdr}`,
+                        invalidate: ctx.invalidate,
+                        key: (width) => `nf:${sharedThemeCacheKey(theme)}:${fp}:${lineCount}:${width}`,
+                        render: async (width) => {
+                            if (!rawContent)
+                                return `${newHdr}`;
+                            const hlLines = await hlBlock(rawContent, lg);
                             const maxShow = hlLines.length;
-                            const preview = hlLines.slice(0, maxShow).join("\n");
+                            const preview = hlLines.slice(0, maxShow).join("\n").replace(/\n+$/, "");
                             const rem = hlLines.length - maxShow;
-                            let out = `${newHdr}\n${padDiffBody(preview)}`;
-                            if (rem > 0)
-                                out += `\n${bgLine(`${TOOL_RESULT_INDENT}${theme.fg("muted", `… ${rem} more lines`)}`, w)}`;
-                            ctx.state._nft = out;
-                            ctx.invalidate();
-                        })
-                            .catch(() => { });
-                    }
+                            const moreLine = rem > 0
+                                ? `\n${bgLine(`${TOOL_RESULT_INDENT}${theme.fg("muted", `… ${rem} more lines`)}`, width)}`
+                                : "";
+                            return `${newHdr}\n${padDiffBody(preview)}${moreLine}`;
+                        },
+                    };
                 }
-                text.setText(ctx.state._nft ?? newHdr);
                 return text;
             }
             text.setText(`${TOOL_RESULT_INDENT}${theme.fg("dim", String(result?.content?.[0]?.text ?? "written").slice(0, 120))}`);
@@ -1526,8 +1577,60 @@ export default async function diffRendererExtension(pi) {
     pi.registerTool({
         ...origEdit,
         name: "edit",
+        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).",
+                },
+                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,
+                    },
+                },
+            },
+        },
         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)) {
@@ -1709,12 +1812,8 @@ export default async function diffRendererExtension(pi) {
             const operations = getEditOperations(args);
             const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
             resolvePreviewDiffColors(theme);
+            const stats = editCallStatsSuffix(ctx.toolCallId, theme);
             if (ctx.argsComplete && operations.length > 0) {
-                const { totalAdded, totalRemoved } = summarizeEditOperations(operations);
-                // Compute the line number for the call preview by reading the
-                // file and finding the first oldText. This lets the title show
-                // "at line N" even before the edit executes, matching what the
-                // result title will show.
                 let previewLine = 0;
                 try {
                     if (fp && existsSync(fp)) {
@@ -1728,10 +1827,28 @@ export default async function diffRendererExtension(pi) {
                     previewLine = 0;
                 }
                 const loc = previewLine > 0 ? ` ${theme.fg("muted", `at line ${previewLine}`)}` : "";
-                text.setText(formatToolTitle("edit", fp, theme, termW(), `${TOOL_RESULT_INDENT}${theme.fg("muted", editEditsCountLabel(operations.length, totalAdded + totalRemoved, theme))} ${summarizeThemed(totalAdded, totalRemoved, theme)}${loc}`));
+                text.setText(formatToolFrameHeader({
+                    label: "edit",
+                    filePath: fp,
+                    theme,
+                    width: termW(),
+                    suffix: `${stats}${loc}`,
+                    topPad: EDIT_DIFF_RESULT_FRAME.topPad,
+                    bottomPad: EDIT_DIFF_RESULT_FRAME.bottomPad,
+                    headerLeftPad: EDIT_DIFF_RESULT_FRAME.headerLeftPad,
+                }));
             }
             else {
-                text.setText(formatToolTitle("edit", fp, theme, termW()));
+                text.setText(formatToolFrameHeader({
+                    label: "edit",
+                    filePath: fp,
+                    theme,
+                    width: termW(),
+                    suffix: stats,
+                    topPad: EDIT_DIFF_RESULT_FRAME.topPad,
+                    bottomPad: EDIT_DIFF_RESULT_FRAME.bottomPad,
+                    headerLeftPad: EDIT_DIFF_RESULT_FRAME.headerLeftPad,
+                }));
             }
             return text;
         },
@@ -1748,20 +1865,20 @@ 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);
+                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 === "editInfo") {
-                setToolHeaderText(text, "", theme);
+            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 });
                 return text;
             }
             if (d?._type === "multiEditInfo") {
                 const { editCount, diffLineCount, diff, language } = d;
-                const meta = `${editCount} edits${diffLineCountLabel(diffLineCount, theme)}`;
                 if (diff) {
-                    setDiffPreviewTask(text, "me", meta, diff, language, MAX_PREVIEW_LINES, theme, ctx);
+                    setDiffPreviewTask(text, "me", "", diff, language, MAX_PREVIEW_LINES, theme, ctx, { omitHeader: true, previewBottomPad: EDIT_DIFF_RESULT_FRAME.previewBottomPad });
                     return text;
                 }
+                const meta = `${editCount} edits${diffLineCountLabel(diffLineCount, theme)}`;
                 setToolHeaderText(text, meta, theme);
                 return text;
             }
@@ -1770,6 +1887,171 @@ export default async function diffRendererExtension(pi) {
             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,
+        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: {
+                    type: "array",
+                    description: "Atomic list of range replacements (empty content_lines deletes the range).",
+                    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" },
+                            },
+                        },
+                        required: ["hash_range_inclusive", "content_lines"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            required: ["path", "hashlineChanges"],
+            additionalProperties: false,
+        },
+        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,
+                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: {} };
+            }
+            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 });
+                return text;
+            }
+            // Fallback for errors / no-diff
+            text.__piDiffTask = undefined;
+            const out = (result.content || []).map((c) => c.text).join("\n");
+            text.setText(theme.fg(ctx.isError ? "error" : "muted", out));
+            return text;
+        },
+    });
     registerEditGuard(pi);
 }
 //# sourceMappingURL=index.js.map