@heyhuynhgiabuu/pi-diff 0.5.1 → 0.5.3

package/dist/index.js

@@ -24,12 +24,10 @@ import { existsSync, readFileSync } from "node:fs";
 import { extname, relative } from "node:path";
 import { codeToANSI } from "@shikijs/cli";
 import * as Diff from "diff";
-import { parseDiff } from "./core/diff.js";
+import { computeHunkBlocks, getSepStyle, parseDiff, parsePatchFiles, resolveSepStyle, sepLabelSplit, sepLabelUnified } from "./core/diff.js";
+import { resolveLinesFromPatch } from "./core/resolve-lines.js";
 import { registerReviewDiffCommand } from "./review/command.js";
-import { formatReviewMarkdown } from "./review/export.js";
-import { countReviewDiffLines, readGitDiff } from "./review/git.js";
 import { applyDiffPalette as applySharedDiffPalette, lang as detectDiffLanguage, renderSplit as renderSharedSplit, resolveDiffColors as resolveSharedDiffColors, themeCacheKey as sharedThemeCacheKey, } from "./review/hunk-preview.js";
-import { formatInteractiveReviewPanel } from "./review/interactive.js";
 const DIFF_PRESETS = {
     default: {
         name: "default",
@@ -926,10 +924,9 @@ async function renderUnified(diff, language, max = MAX_RENDER_LINES, dc = DEFAUL
     }
     while (idx < vis.length) {
         const l = vis[idx];
-        // Hunk separator — collapsed context
+        // Hunk separator — collapsed context with optional function context
         if (l.type === "sep") {
-            const gap = l.newNum;
-            const label = gap && gap > 0 ? ` ${gap} unmodified lines ` : "···";
+            const label = sepLabelUnified(getSepStyle(), l.hunkMeta, l.newNum, l.content);
             const totalW = Math.min(tw, 72);
             const pad = Math.max(0, totalW - label.length - 2);
             const half1 = Math.floor(pad / 2), half2 = pad - half1;
@@ -1009,16 +1006,23 @@ async function renderSplit(diff, language, max = MAX_PREVIEW_LINES, dc = DEFAULT
     let i = 0;
     while (i < diff.lines.length) {
         const l = diff.lines[i];
-        if (l.type === "sep" || l.type === "ctx") {
+        if (l.type === "ctx") {
+            rows.push({ left: l, right: l });
+            i++;
+            continue;
+        }
+        if (l.type === "sep") {
             rows.push({ left: l, right: l });
             i++;
             continue;
         }
-        const dels = [], adds = [];
+        // Collect del/add block
+        const dels = [];
         while (i < diff.lines.length && diff.lines[i].type === "del") {
             dels.push(diff.lines[i]);
             i++;
         }
+        const adds = [];
         while (i < diff.lines.length && diff.lines[i].type === "add") {
             adds.push(diff.lines[i]);
             i++;
@@ -1054,10 +1058,9 @@ async function renderSplit(diff, language, max = MAX_PREVIEW_LINES, dc = DEFAULT
             const g = ` ${gPat}${FG_RULE}│${RST} `;
             return { gutter: g, contGutter: g, bodyRows: [stripes(cw, stripeRow)] };
         }
-        // Hunk separator
+        // Hunk separator with optional function context
         if (line.type === "sep") {
-            const gap = line.newNum;
-            const label = gap && gap > 0 ? `··· ${gap} lines ···` : "···";
+            const label = sepLabelSplit(getSepStyle(), line.hunkMeta, line.newNum, line.content);
             const g = `${BG_BASE} ${FG_DIM}${fit("", nw + 2)}${RST}${FG_RULE}│${RST} `;
             return { gutter: g, contGutter: g, bodyRows: [`${BG_BASE}${FG_DIM}${fit(label, cw)}${RST}`] };
         }
@@ -1139,35 +1142,20 @@ async function renderSplit(diff, language, max = MAX_PREVIEW_LINES, dc = DEFAULT
 // Extension
 // ---------------------------------------------------------------------------
 export const __testing = {
+    computeHunkBlocks,
     normalizeShikiContrast,
+    getSepStyle,
     parseDiff,
+    parsePatchFiles,
+    resolveSepStyle,
     renderSplit,
     renderUnified,
 };
-function reviewGitDiffMode(params) {
-    const base = typeof params.base === "string" ? params.base.trim() : "";
-    return base ? { type: "branch", base } : { type: "working-tree" };
-}
-function reviewGitDiffMaxLines(params) {
-    if (params.maxLinesPerHunk === undefined)
-        return undefined;
-    const maxLines = Number(params.maxLinesPerHunk);
-    if (!Number.isInteger(maxLines) || maxLines < 1) {
-        throw new Error("maxLinesPerHunk must be a positive integer");
-    }
-    return maxLines;
-}
-function normalizeOptionalPositiveInteger(value, name) {
-    if (value === undefined || value === null)
-        return undefined;
-    const number = Number(value);
-    if (!Number.isInteger(number) || number < 1)
-        throw new Error(`${name} must be a positive integer`);
-    return number;
-}
 export default async function diffRendererExtension(pi) {
     // Apply diff theme palette from settings/presets before rendering
     applySharedDiffPalette();
+    // Resolve hunk separator style from env var
+    resolveSepStyle();
     let createWriteTool, createEditTool, getMarkdownTheme, TextComponent, MarkdownComponent;
     try {
         const sdk = await import("@earendil-works/pi-coding-agent");
@@ -1226,121 +1214,127 @@ export default async function diffRendererExtension(pi) {
         return text;
     }
     registerReviewDiffCommand(pi, cwd);
+    // ── resolve_lines tool ────────────────────────────────────────────────
     pi.registerTool({
-        name: "review_git_diff",
-        label: "Review Git Diff",
-        description: `Open a read-only Git diff review panel as markdown inside Pi TUI.
+        name: "resolve_lines",
+        label: "Resolve Lines",
+        description: `Resolve line numbers for an LLM code-review comment by matching its existing_code snippet against the git diff hunks. Uses a three-tier algorithm: new-side hunk match, old-side hunk match, then full file-content scan. Returns \`startLine\` and \`endLine\` when found, or \`unresolved: true\` when the snippet cannot be located.
 
-Use this when the agent needs structured Git review context or a non-destructive markdown view of local changes. For the real keyboard-driven local review UI, use the /review-diff command instead. This tool never stages, commits, reverts, discards, or modifies files.
+Three-tier resolution:
+  1. Match against diff hunks (new-file side) — context + added lines
+  2. Match against diff hunks (old-file side) — context + deleted lines
+  3. Scan full file content for a consecutive line match
+
+Use after receiving a review comment with \`existing_code\` but zero or drifted line numbers. The tool fetches the current git diff for the file automatically when \`patchText\` is omitted.
 
 Examples:
-  review_git_diff({})
-  review_git_diff({ base: "main" })
-  review_git_diff({ file: "src/index.ts" })
-  review_git_diff({ file: "src/index.ts", hunkId: "src/index.ts:10:12" })`,
-        promptSnippet: "Open a read-only Git review markdown panel for local changes. Prefer /review-diff for the interactive TUI workflow.",
+  resolve_lines({ existingCode: "const x = 1;", filePath: "src/index.ts" })
+  resolve_lines({ existingCode: "function foo() {", filePath: "src/utils.ts", patchText: "@@ -1,3 +1,4 @@..." })`,
+        promptSnippet: "Resolve line numbers for an LLM review comment by matching existing_code against git diff hunks.",
         parameters: {
             type: "object",
             properties: {
-                base: {
+                existingCode: {
                     type: "string",
-                    description: "Optional base branch/ref. Omit for uncommitted working-tree changes; set to main/master/etc. for base...HEAD branch review.",
+                    description: "The code snippet from the LLM review comment that shows the problematic code. Required.",
                 },
-                file: {
+                filePath: {
                     type: "string",
-                    description: "Optional changed file path to focus in the interactive review panel.",
+                    description: "Path to the file this comment is about, relative to repo root. Required.",
                 },
-                hunkId: {
+                patchText: {
                     type: "string",
-                    description: "Optional hunk id to focus, shown by review_git_diff output.",
-                },
-                includeRawDiff: {
-                    type: "boolean",
-                    description: "Return legacy raw review markdown instead of the interactive panel when true.",
-                },
-                raw: {
-                    type: "boolean",
-                    description: "Alias for includeRawDiff.",
-                },
-                maxLinesPerHunk: {
-                    type: "number",
-                    description: "Optional positive integer limit for lines shown per hunk.",
+                    description: "Optional raw unified diff text for the file. When omitted, pi-diff fetches the git diff automatically.",
                 },
-                maxFiles: {
-                    type: "number",
-                    description: "Optional positive integer limit for files shown in the changed-file sidebar.",
-                },
-                maxHunks: {
-                    type: "number",
-                    description: "Optional positive integer limit for hunks shown in the focused file view.",
+                fileContent: {
+                    type: "string",
+                    description: "Optional full new-file content for fallback line scan after hunk matching fails.",
                 },
             },
+            required: ["existingCode", "filePath"],
             additionalProperties: false,
         },
         async execute(_tid, params = {}) {
             try {
-                const safeParams = (params ?? {});
-                const diff = await readGitDiff(cwd, reviewGitDiffMode(safeParams));
-                const maxLinesPerHunk = reviewGitDiffMaxLines(safeParams);
-                const markdown = safeParams.includeRawDiff || safeParams.raw
-                    ? formatReviewMarkdown(diff, { includeRawDiff: true, maxLinesPerHunk })
-                    : formatInteractiveReviewPanel(diff, [], {
-                        file: safeParams.file,
-                        hunkId: safeParams.hunkId,
-                        maxFiles: normalizeOptionalPositiveInteger(safeParams.maxFiles, "maxFiles"),
-                        maxHunks: normalizeOptionalPositiveInteger(safeParams.maxHunks, "maxHunks"),
-                        maxLinesPerHunk,
-                    });
-                const counts = countReviewDiffLines(diff);
+                const { existingCode, filePath, patchText, fileContent } = params ?? {};
+                if (!existingCode || !filePath) {
+                    return { content: [{ type: "text", text: "Error: existingCode and filePath are required" }] };
+                }
+                // Fetch git diff if patchText not provided
+                let patch = patchText;
+                if (!patch) {
+                    const { execFileSync } = await import("node:child_process");
+                    try {
+                        patch = execFileSync("git", ["diff", "--no-ext-diff", "HEAD", "--", filePath], {
+                            cwd,
+                            encoding: "utf8",
+                            maxBuffer: 1024 * 1024,
+                            stdio: ["ignore", "pipe", "pipe"],
+                        }).trim();
+                        // Also try unstaged diff
+                        const unstaged = execFileSync("git", ["diff", "--no-ext-diff", "--", filePath], {
+                            cwd,
+                            encoding: "utf8",
+                            maxBuffer: 1024 * 1024,
+                            stdio: ["ignore", "pipe", "pipe"],
+                        }).trim();
+                        if (unstaged) {
+                            patch = patch ? [patch, unstaged].filter(Boolean).join("\n") : unstaged;
+                        }
+                    }
+                    catch {
+                        return {
+                            content: [{ type: "text", text: `Error: could not read git diff for ${filePath}` }],
+                        };
+                    }
+                }
+                if (!patch) {
+                    return {
+                        content: [{ type: "text", text: `No diff found for ${filePath} — file may not have changes` }],
+                        details: { unresolved: true },
+                    };
+                }
+                const result = resolveLinesFromPatch(existingCode, patch, fileContent);
+                if ("unresolved" in result) {
+                    return {
+                        content: [{ type: "text", text: `Could not resolve line numbers for existing_code in ${filePath}` }],
+                        details: { unresolved: true },
+                    };
+                }
                 return {
-                    content: [{ type: "text", text: markdown }],
-                    details: {
-                        _type: "reviewGitDiff",
-                        markdown,
-                        mode: String(diff.mode),
-                        fileCount: diff.files.length,
-                        insertions: counts.insertions,
-                        deletions: counts.deletions,
-                        commentCount: 0,
-                        focusedFile: safeParams.file,
-                        focusedHunk: safeParams.hunkId,
-                        error: undefined,
-                    },
+                    content: [{ type: "text", text: `Resolved ${filePath}:${result.startLine}-${result.endLine}` }],
+                    details: { startLine: result.startLine, endLine: result.endLine },
                 };
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 return {
                     content: [{ type: "text", text: `Error: ${message}` }],
-                    details: { _type: "reviewGitDiff", markdown: "", mode: "error", fileCount: 0, insertions: 0, deletions: 0, commentCount: 0, focusedFile: undefined, focusedHunk: undefined, error: message },
+                    details: { unresolved: true, error: message },
                 };
             }
         },
         renderCall(args, theme, ctx) {
             const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
-            const safeArgs = args;
-            const base = typeof safeArgs?.base === "string" && safeArgs.base.trim() ? ` vs ${safeArgs.base.trim()}` : " working tree";
-            const focus = typeof safeArgs?.file === "string" && safeArgs.file.trim() ? ` • ${safeArgs.file.trim()}` : "";
-            text.setText(`${theme.fg("toolTitle", theme.bold("review_git_diff"))}${theme.fg("muted", `${base}${focus}`)}`);
+            const fp = typeof args?.filePath === "string" ? args.filePath : "";
+            text.setText(`${theme.fg("toolTitle", theme.bold("resolve_lines"))} ${theme.fg("accent", fp)}`);
             return text;
         },
         renderResult(result, _opt, theme, ctx) {
             const text = ctx.lastComponent ?? new TextComponent("", 0, 0);
             if (ctx.isError || result.details?.error) {
-                text.setText(`\n${theme.fg("error", result.details?.error ?? "review_git_diff failed")}`);
+                text.setText(`\n${theme.fg("error", result.details?.error ?? "resolve_lines failed")}`);
                 return text;
             }
-            const details = result.details;
-            if (details?._type === "reviewGitDiff") {
-                if (MarkdownComponent && getMarkdownTheme && typeof details.markdown === "string") {
-                    return new MarkdownComponent(details.markdown, 0, 0, getMarkdownTheme());
-                }
-                const summary = `${details.fileCount} files ${summarize(details.insertions ?? 0, details.deletions ?? 0)}`;
-                const comments = details.commentCount ? ` • ${details.commentCount} comments` : "";
-                text.setText(`  ${summary}${theme.fg("muted", comments)}\n${theme.fg("muted", "  Interactive review panel generated in the tool result.")}`);
+            if (result.details?.unresolved) {
+                text.setText(`  ${theme.fg("muted", "unresolved")}`);
+                return text;
+            }
+            if (result.details?.startLine != null) {
+                text.setText(`  ${theme.fg("success", `lines ${result.details.startLine}-${result.details.endLine}`)}`);
                 return text;
             }
-            text.setText(`  ${theme.fg("muted", "interactive review generated")}`);
+            text.setText(`  ${theme.fg("dim", String(result?.content?.[0]?.text ?? "").slice(0, 120))}`);
             return text;
         },
     });
@@ -1365,9 +1359,10 @@ Examples:
             const content = params.content ?? "";
             // Store in details — the only custom field TUI preserves in renderResult
             if (old !== null && old !== content) {
-                const diff = parseDiff(old, content);
+                const useFull = !!params._expandGaps;
+                const diff = parseDiff(old, content, useFull ? undefined : 3);
                 const lg = detectDiffLanguage(fp);
-                result.details = { _type: "diff", summary: summarize(diff.added, diff.removed), diff, language: lg };
+                result.details = { _type: "diff", summary: summarize(diff.added, diff.removed), diff, language: lg, oldContent: old, newContent: content };
             }
             else if (old === null) {
                 const lineCount = content ? content.split("\n").length : 0;
@@ -1530,14 +1525,39 @@ Examples:
                 catch {
                     editLine = 0;
                 }
-                result.details = { _type: "editInfo", summary, editLine, diff: diffs[0], language: lg };
+                const useFull = !!params._expandGaps;
+                const diffData = useFull
+                    ? parseDiff(operations[0].oldText, operations[0].newText, undefined)
+                    : diffs[0];
+                result.details = {
+                    _type: "editInfo",
+                    summary,
+                    editLine,
+                    diff: diffData,
+                    language: lg,
+                    oldContent: operations[0].oldText,
+                    newContent: operations[0].newText,
+                };
                 return result;
             }
+            // Merge all diffs into one combined view for rendering
+            const merged = {
+                lines: diffs.flatMap((diff, i) => [
+                    // Add separator between multiple edits
+                    ...(i > 0 ? [{ type: "sep", oldNum: null, newNum: null, content: `───── Edit ${i + 1} ─────` }] : []),
+                    ...diff.lines,
+                ]),
+                added: diffs.reduce((sum, diff) => sum + diff.added, 0),
+                removed: diffs.reduce((sum, diff) => sum + diff.removed, 0),
+                chars: diffs.reduce((sum, diff) => sum + diff.chars, 0),
+            };
             result.details = {
                 _type: "multiEditInfo",
                 summary,
                 editCount: operations.length,
-                diffLineCount: diffs.reduce((sum, diff) => sum + diff.lines.length, 0),
+                diffLineCount: merged.lines.length,
+                diff: merged,
+                language: lg,
             };
             return result;
         },
@@ -1588,7 +1608,20 @@ Examples:
                 return text;
             }
             if (d?._type === "multiEditInfo") {
-                const { summary: s, editCount, diffLineCount } = d;
+                const { summary: s, editCount, diffLineCount, diff, language } = d;
+                if (diff) {
+                    const themeKey = sharedThemeCacheKey(theme);
+                    const dc = resolveSharedDiffColors(theme);
+                    text.__piDiffTask = {
+                        placeholder: `  ${editCount} edits ${s}
+${theme.fg("muted", "  rendering diff…")}`,
+                        fallback: `  ${editCount} edits ${s}${typeof diffLineCount === "number" ? ` ${theme.fg("muted", `(${diffLineCount} diff lines)`)}` : ""}`,
+                        invalidate: ctx.invalidate,
+                        key: (width) => `me:${themeKey}:${width}:${s}:${diff?.lines?.length ?? 0}:${language ?? ""}`,
+                        render: async (width) => `  ${editCount} edits ${s}${typeof diffLineCount === "number" ? ` ${theme.fg("muted", `(${diffLineCount} diff lines)`)}` : ""}\n${await renderSharedSplit(diff, language, MAX_PREVIEW_LINES, dc, width)}`,
+                    };
+                    return text;
+                }
                 text.__piDiffTask = undefined;
                 text.setText(`  ${editCount} edits ${s}${typeof diffLineCount === "number" ? ` ${theme.fg("muted", `(${diffLineCount} diff lines)`)}` : ""}`);
                 return text;