@fresh-editor/fresh-editor 0.1.67 → 0.1.69

package/plugins/audit_mode.ts

@@ -1,11 +1,13 @@
 // Review Diff Plugin
 // Provides a unified workflow for reviewing code changes (diffs, conflicts, AI outputs).
+const editor = getEditor();
 
 /// <reference path="./lib/fresh.d.ts" />
 /// <reference path="./lib/types.ts" />
 /// <reference path="./lib/virtual-buffer-factory.ts" />
 
-import { VirtualBufferFactory } from "./lib/virtual-buffer-factory.ts";
+import { createVirtualBufferFactory } from "./lib/virtual-buffer-factory.ts";
+const VirtualBufferFactory = createVirtualBufferFactory(editor);
 
 /**
  * Hunk status for staging
@@ -210,6 +212,7 @@ interface HighlightTask {
     bg?: [number, number, number];
     bold?: boolean;
     italic?: boolean;
+    extend_to_line_end?: boolean;
 }
 
 /**
@@ -222,31 +225,31 @@ async function renderReviewStream(): Promise<{ entries: TextPropertyEntry[], hig
   let currentByte = 0;
 
   // Add help header with keybindings at the TOP
-  const helpHeader = "╔══════════════════════════════════════════════════════════════════════════╗\n";
+  const helpHeader = "╔" + "═".repeat(74) + "╗\n";
   const helpLen0 = getByteLength(helpHeader);
   entries.push({ text: helpHeader, properties: { type: "help" } });
   highlights.push({ range: [currentByte, currentByte + helpLen0], fg: STYLE_COMMENT_BORDER });
   currentByte += helpLen0;
 
-  const helpLine1 = "║ REVIEW: [c]omment [a]pprove [x]reject [!]changes [?]question [u]ndo       ║\n";
+  const helpLine1 = "║ " + editor.t("panel.help_review").padEnd(72) + " ║\n";
   const helpLen1 = getByteLength(helpLine1);
   entries.push({ text: helpLine1, properties: { type: "help" } });
   highlights.push({ range: [currentByte, currentByte + helpLen1], fg: STYLE_COMMENT });
   currentByte += helpLen1;
 
-  const helpLine2 = "║ STAGE:  [s]tage [d]iscard | NAV: [n]ext [p]rev [Enter]drill [q]uit        ║\n";
+  const helpLine2 = "║ " + editor.t("panel.help_stage").padEnd(72) + " ║\n";
   const helpLen2 = getByteLength(helpLine2);
   entries.push({ text: helpLine2, properties: { type: "help" } });
   highlights.push({ range: [currentByte, currentByte + helpLen2], fg: STYLE_COMMENT });
   currentByte += helpLen2;
 
-  const helpLine3 = "║ EXPORT: [E] .review/session.md | [O]verall feedback | [r]efresh           ║\n";
+  const helpLine3 = "║ " + editor.t("panel.help_export").padEnd(72) + " ║\n";
   const helpLen3 = getByteLength(helpLine3);
   entries.push({ text: helpLine3, properties: { type: "help" } });
   highlights.push({ range: [currentByte, currentByte + helpLen3], fg: STYLE_COMMENT });
   currentByte += helpLen3;
 
-  const helpFooter = "╚══════════════════════════════════════════════════════════════════════════╝\n\n";
+  const helpFooter = "╚" + "═".repeat(74) + "╝\n\n";
   const helpLen4 = getByteLength(helpFooter);
   entries.push({ text: helpFooter, properties: { type: "help" } });
   highlights.push({ range: [currentByte, currentByte + helpLen4], fg: STYLE_COMMENT_BORDER });
@@ -509,7 +512,7 @@ async function renderReviewStream(): Promise<{ entries: TextPropertyEntry[], hig
   }
 
   if (entries.length === 0) {
-    entries.push({ text: "No changes to review.\n", properties: {} });
+    entries.push({ text: editor.t("panel.no_changes") + "\n", properties: {} });
   } else {
     // Add help footer with keybindings
     const helpSeparator = "\n" + "─".repeat(70) + "\n";
@@ -518,19 +521,19 @@ async function renderReviewStream(): Promise<{ entries: TextPropertyEntry[], hig
     highlights.push({ range: [currentByte, currentByte + helpLen1], fg: STYLE_BORDER });
     currentByte += helpLen1;
 
-    const helpLine1 = "REVIEW: [c]omment  [a]pprove  [x]reject  [!]needs-changes  [?]question  [u]ndo\n";
+    const helpLine1 = editor.t("panel.help_review_footer") + "\n";
     const helpLen2 = getByteLength(helpLine1);
     entries.push({ text: helpLine1, properties: { type: "help" } });
     highlights.push({ range: [currentByte, currentByte + helpLen2], fg: STYLE_COMMENT });
     currentByte += helpLen2;
 
-    const helpLine2 = "STAGE:  [s]tage    [d]iscard  |  NAV: [n]ext [p]rev [Enter]drill-down  [q]uit\n";
+    const helpLine2 = editor.t("panel.help_stage_footer") + "\n";
     const helpLen3 = getByteLength(helpLine2);
     entries.push({ text: helpLine2, properties: { type: "help" } });
     highlights.push({ range: [currentByte, currentByte + helpLen3], fg: STYLE_COMMENT });
     currentByte += helpLen3;
 
-    const helpLine3 = "EXPORT: [E]xport to .review/session.md  |  [O]verall feedback  [r]efresh\n";
+    const helpLine3 = editor.t("panel.help_export_footer") + "\n";
     const helpLen4 = getByteLength(helpLine3);
     entries.push({ text: helpLine3, properties: { type: "help" } });
     highlights.push({ range: [currentByte, currentByte + helpLen4], fg: STYLE_COMMENT });
@@ -572,13 +575,13 @@ async function updateReviewUI() {
 async function refreshReviewData() {
     if (isUpdating) return;
     isUpdating = true;
-    editor.setStatus("Refreshing review diff...");
+    editor.setStatus(editor.t("status.refreshing"));
     try {
         const newHunks = await getGitDiff();
         newHunks.forEach(h => h.status = state.hunkStatus[h.id] || 'pending');
         state.hunks = newHunks;
         await updateReviewUI();
-        editor.setStatus(`Review diff updated. Found ${state.hunks.length} hunks.`);
+        editor.setStatus(editor.t("status.updated", { count: String(state.hunks.length) }));
     } catch (e) {
         editor.debug(`ReviewDiff Error: ${e}`);
     } finally {
@@ -641,12 +644,371 @@ globalThis.review_refresh = () => { refreshReviewData(); };
 
 let activeDiffViewState: { lSplit: number, rSplit: number } | null = null;
 
+/**
+ * Find line number for a given byte offset using binary search
+ */
+function findLineForByte(lineByteOffsets: number[], topByte: number): number {
+    let low = 0;
+    let high = lineByteOffsets.length - 1;
+    while (low < high) {
+        const mid = Math.floor((low + high + 1) / 2);
+        if (lineByteOffsets[mid] <= topByte) {
+            low = mid;
+        } else {
+            high = mid - 1;
+        }
+    }
+    return low;
+}
+
 globalThis.on_viewport_changed = (data: any) => {
-    if (!activeDiffViewState) return;
-    if (data.split_id === activeDiffViewState.lSplit) (editor as any).setSplitScroll(activeDiffViewState.rSplit, data.top_byte);
-    else if (data.split_id === activeDiffViewState.rSplit) (editor as any).setSplitScroll(activeDiffViewState.lSplit, data.top_byte);
+    // This handler is now a no-op - scroll sync is handled by the core
+    // using the anchor-based ScrollSyncGroup system.
+    // Keeping the handler for backward compatibility if core sync fails.
+    if (!activeDiffViewState || !activeSideBySideState) return;
+
+    // Skip if core scroll sync is active (we have a scrollSyncGroupId)
+    if (activeSideBySideState.scrollSyncGroupId !== null) return;
+
+    const { oldSplitId, newSplitId, oldLineByteOffsets, newLineByteOffsets } = activeSideBySideState;
+
+    if (data.split_id === oldSplitId && newLineByteOffsets.length > 0) {
+        // OLD pane scrolled - find which line it's on and sync NEW pane to same line
+        const lineNum = findLineForByte(oldLineByteOffsets, data.top_byte);
+        const targetByte = newLineByteOffsets[Math.min(lineNum, newLineByteOffsets.length - 1)];
+        (editor as any).setSplitScroll(newSplitId, targetByte);
+    } else if (data.split_id === newSplitId && oldLineByteOffsets.length > 0) {
+        // NEW pane scrolled - find which line it's on and sync OLD pane to same line
+        const lineNum = findLineForByte(newLineByteOffsets, data.top_byte);
+        const targetByte = oldLineByteOffsets[Math.min(lineNum, oldLineByteOffsets.length - 1)];
+        (editor as any).setSplitScroll(oldSplitId, targetByte);
+    }
 };
 
+/**
+ * Represents an aligned line pair for side-by-side diff display
+ */
+interface AlignedLine {
+    oldLine: string | null;  // null means filler line
+    newLine: string | null;  // null means filler line
+    oldLineNum: number | null;
+    newLineNum: number | null;
+    changeType: 'unchanged' | 'added' | 'removed' | 'modified';
+}
+
+/**
+ * Parse git diff and compute fully aligned line pairs for side-by-side display.
+ * Shows the complete files with proper alignment through all hunks.
+ */
+function computeFullFileAlignedDiff(oldContent: string, newContent: string, hunks: Hunk[]): AlignedLine[] {
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    const aligned: AlignedLine[] = [];
+
+    // Build a map of changes from all hunks for this file
+    // Key: old line number (1-based), Value: { type, newLineNum, content }
+    interface ChangeInfo {
+        type: 'removed' | 'added' | 'modified' | 'context';
+        oldContent?: string;
+        newContent?: string;
+        newLineNum?: number;
+    }
+
+    // Parse all hunks for this file
+    const allHunkChanges: { oldStart: number, newStart: number, changes: { type: 'add' | 'remove' | 'context', content: string }[] }[] = [];
+    for (const hunk of hunks) {
+        const changes: { type: 'add' | 'remove' | 'context', content: string }[] = [];
+        for (const line of hunk.lines) {
+            if (line.startsWith('+')) {
+                changes.push({ type: 'add', content: line.substring(1) });
+            } else if (line.startsWith('-')) {
+                changes.push({ type: 'remove', content: line.substring(1) });
+            } else if (line.startsWith(' ')) {
+                changes.push({ type: 'context', content: line.substring(1) });
+            }
+        }
+        allHunkChanges.push({
+            oldStart: hunk.oldRange.start,
+            newStart: hunk.range.start,
+            changes
+        });
+    }
+
+    // Sort hunks by old line start
+    allHunkChanges.sort((a, b) => a.oldStart - b.oldStart);
+
+    // Process the file line by line
+    let oldIdx = 0;  // 0-based index into oldLines
+    let newIdx = 0;  // 0-based index into newLines
+    let hunkIdx = 0;
+
+    while (oldIdx < oldLines.length || newIdx < newLines.length || hunkIdx < allHunkChanges.length) {
+        // Check if we're at a hunk boundary
+        const currentHunk = hunkIdx < allHunkChanges.length ? allHunkChanges[hunkIdx] : null;
+
+        if (currentHunk && oldIdx + 1 === currentHunk.oldStart) {
+            // Process this hunk
+            let changeIdx = 0;
+            while (changeIdx < currentHunk.changes.length) {
+                const change = currentHunk.changes[changeIdx];
+
+                if (change.type === 'context') {
+                    aligned.push({
+                        oldLine: oldLines[oldIdx],
+                        newLine: newLines[newIdx],
+                        oldLineNum: oldIdx + 1,
+                        newLineNum: newIdx + 1,
+                        changeType: 'unchanged'
+                    });
+                    oldIdx++;
+                    newIdx++;
+                    changeIdx++;
+                } else if (change.type === 'remove') {
+                    // Look ahead to see if next is an 'add' (modification)
+                    if (changeIdx + 1 < currentHunk.changes.length &&
+                        currentHunk.changes[changeIdx + 1].type === 'add') {
+                        // Modified line
+                        aligned.push({
+                            oldLine: oldLines[oldIdx],
+                            newLine: newLines[newIdx],
+                            oldLineNum: oldIdx + 1,
+                            newLineNum: newIdx + 1,
+                            changeType: 'modified'
+                        });
+                        oldIdx++;
+                        newIdx++;
+                        changeIdx += 2;
+                    } else {
+                        // Pure removal
+                        aligned.push({
+                            oldLine: oldLines[oldIdx],
+                            newLine: null,
+                            oldLineNum: oldIdx + 1,
+                            newLineNum: null,
+                            changeType: 'removed'
+                        });
+                        oldIdx++;
+                        changeIdx++;
+                    }
+                } else if (change.type === 'add') {
+                    // Pure addition
+                    aligned.push({
+                        oldLine: null,
+                        newLine: newLines[newIdx],
+                        oldLineNum: null,
+                        newLineNum: newIdx + 1,
+                        changeType: 'added'
+                    });
+                    newIdx++;
+                    changeIdx++;
+                }
+            }
+            hunkIdx++;
+        } else if (oldIdx < oldLines.length && newIdx < newLines.length) {
+            // Not in a hunk - add unchanged line
+            aligned.push({
+                oldLine: oldLines[oldIdx],
+                newLine: newLines[newIdx],
+                oldLineNum: oldIdx + 1,
+                newLineNum: newIdx + 1,
+                changeType: 'unchanged'
+            });
+            oldIdx++;
+            newIdx++;
+        } else if (oldIdx < oldLines.length) {
+            // Only old lines left (shouldn't happen normally)
+            aligned.push({
+                oldLine: oldLines[oldIdx],
+                newLine: null,
+                oldLineNum: oldIdx + 1,
+                newLineNum: null,
+                changeType: 'removed'
+            });
+            oldIdx++;
+        } else if (newIdx < newLines.length) {
+            // Only new lines left
+            aligned.push({
+                oldLine: null,
+                newLine: newLines[newIdx],
+                oldLineNum: null,
+                newLineNum: newIdx + 1,
+                changeType: 'added'
+            });
+            newIdx++;
+        } else {
+            break;
+        }
+    }
+
+    return aligned;
+}
+
+/**
+ * Generate virtual buffer content with diff highlighting for one side.
+ * Returns entries, highlight tasks, and line byte offsets for scroll sync.
+ */
+function generateDiffPaneContent(
+    alignedLines: AlignedLine[],
+    side: 'old' | 'new'
+): { entries: TextPropertyEntry[], highlights: HighlightTask[], lineByteOffsets: number[] } {
+    const entries: TextPropertyEntry[] = [];
+    const highlights: HighlightTask[] = [];
+    const lineByteOffsets: number[] = [];
+    let currentByte = 0;
+
+    for (const line of alignedLines) {
+        lineByteOffsets.push(currentByte);
+        const content = side === 'old' ? line.oldLine : line.newLine;
+        const lineNum = side === 'old' ? line.oldLineNum : line.newLineNum;
+        const isFiller = content === null;
+
+        // Format: "│ NNN │ content" or "│     │ ~~~~~~~~" for filler
+        let lineNumStr: string;
+        if (lineNum !== null) {
+            lineNumStr = lineNum.toString().padStart(4, ' ');
+        } else {
+            lineNumStr = '    ';
+        }
+
+        // Gutter marker based on change type
+        let gutterMarker = ' ';
+        if (line.changeType === 'added' && side === 'new') gutterMarker = '+';
+        else if (line.changeType === 'removed' && side === 'old') gutterMarker = '-';
+        else if (line.changeType === 'modified') gutterMarker = '~';
+
+        let lineText: string;
+        if (isFiller) {
+            // Filler line for alignment
+            lineText = `│${gutterMarker}${lineNumStr} │ ${"░".repeat(40)}\n`;
+        } else {
+            lineText = `│${gutterMarker}${lineNumStr} │ ${content}\n`;
+        }
+
+        const lineLen = getByteLength(lineText);
+        const prefixLen = getByteLength(`│${gutterMarker}${lineNumStr} │ `);
+
+        entries.push({
+            text: lineText,
+            properties: {
+                type: 'diff-line',
+                changeType: line.changeType,
+                lineNum: lineNum,
+                side: side
+            }
+        });
+
+        // Apply colors based on change type
+        // Border color
+        highlights.push({ range: [currentByte, currentByte + 1], fg: STYLE_BORDER });
+        highlights.push({ range: [currentByte + prefixLen - 3, currentByte + prefixLen - 1], fg: STYLE_BORDER });
+
+        // Line number color
+        highlights.push({
+            range: [currentByte + 2, currentByte + 6],
+            fg: [120, 120, 120]  // Gray line numbers
+        });
+
+        if (isFiller) {
+            // Filler styling - extend to full line width
+            highlights.push({
+                range: [currentByte + prefixLen, currentByte + lineLen - 1],
+                fg: [60, 60, 60],
+                bg: [30, 30, 30],
+                extend_to_line_end: true
+            });
+        } else if (line.changeType === 'added' && side === 'new') {
+            // Added line (green) - extend to full line width
+            highlights.push({ range: [currentByte + 1, currentByte + 2], fg: STYLE_ADD_TEXT, bold: true }); // gutter marker
+            highlights.push({
+                range: [currentByte + prefixLen, currentByte + lineLen - 1],
+                fg: STYLE_ADD_TEXT,
+                bg: [30, 50, 30],
+                extend_to_line_end: true
+            });
+        } else if (line.changeType === 'removed' && side === 'old') {
+            // Removed line (red) - extend to full line width
+            highlights.push({ range: [currentByte + 1, currentByte + 2], fg: STYLE_REMOVE_TEXT, bold: true }); // gutter marker
+            highlights.push({
+                range: [currentByte + prefixLen, currentByte + lineLen - 1],
+                fg: STYLE_REMOVE_TEXT,
+                bg: [50, 30, 30],
+                extend_to_line_end: true
+            });
+        } else if (line.changeType === 'modified') {
+            // Modified line - show word-level diff
+            const oldText = line.oldLine || '';
+            const newText = line.newLine || '';
+            const diffParts = diffStrings(oldText, newText);
+
+            let offset = currentByte + prefixLen;
+            if (side === 'old') {
+                highlights.push({ range: [currentByte + 1, currentByte + 2], fg: STYLE_REMOVE_TEXT, bold: true });
+                // Highlight removed parts in old line
+                for (const part of diffParts) {
+                    const partLen = getByteLength(part.text);
+                    if (part.type === 'removed') {
+                        highlights.push({
+                            range: [offset, offset + partLen],
+                            fg: STYLE_REMOVE_TEXT,
+                            bg: STYLE_REMOVE_BG,
+                            bold: true
+                        });
+                    } else if (part.type === 'unchanged') {
+                        highlights.push({
+                            range: [offset, offset + partLen],
+                            fg: STYLE_REMOVE_TEXT
+                        });
+                    }
+                    if (part.type !== 'added') {
+                        offset += partLen;
+                    }
+                }
+            } else {
+                highlights.push({ range: [currentByte + 1, currentByte + 2], fg: STYLE_ADD_TEXT, bold: true });
+                // Highlight added parts in new line
+                for (const part of diffParts) {
+                    const partLen = getByteLength(part.text);
+                    if (part.type === 'added') {
+                        highlights.push({
+                            range: [offset, offset + partLen],
+                            fg: STYLE_ADD_TEXT,
+                            bg: STYLE_ADD_BG,
+                            bold: true
+                        });
+                    } else if (part.type === 'unchanged') {
+                        highlights.push({
+                            range: [offset, offset + partLen],
+                            fg: STYLE_ADD_TEXT
+                        });
+                    }
+                    if (part.type !== 'removed') {
+                        offset += partLen;
+                    }
+                }
+            }
+        }
+
+        currentByte += lineLen;
+    }
+
+    return { entries, highlights, lineByteOffsets };
+}
+
+// State for active side-by-side diff view
+interface SideBySideDiffState {
+    oldSplitId: number;
+    newSplitId: number;
+    oldBufferId: number;
+    newBufferId: number;
+    alignedLines: AlignedLine[];
+    oldLineByteOffsets: number[];
+    newLineByteOffsets: number[];
+    scrollSyncGroupId: number | null;  // Core scroll sync group ID
+}
+
+let activeSideBySideState: SideBySideDiffState | null = null;
+let nextScrollSyncGroupId = 1;
+
 globalThis.review_drill_down = async () => {
     const bid = editor.getActiveBufferId();
     const props = editor.getTextPropertiesAtCursor(bid);
@@ -654,39 +1016,201 @@ globalThis.review_drill_down = async () => {
         const id = props[0].hunkId as string;
         const h = state.hunks.find(x => x.id === id);
         if (!h) return;
+
+        editor.setStatus(editor.t("status.loading_diff"));
+
+        // Get all hunks for this file
+        const fileHunks = state.hunks.filter(hunk => hunk.file === h.file);
+
+        // Get git root to construct absolute path
+        const gitRootResult = await editor.spawnProcess("git", ["rev-parse", "--show-toplevel"]);
+        if (gitRootResult.exit_code !== 0) {
+            editor.setStatus(editor.t("status.not_git_repo"));
+            return;
+        }
+        const gitRoot = gitRootResult.stdout.trim();
+        const absoluteFilePath = editor.pathJoin(gitRoot, h.file);
+
+        // Get old (HEAD) and new (working) file content
         const gitShow = await editor.spawnProcess("git", ["show", `HEAD:${h.file}`]);
-        if (gitShow.exit_code !== 0) return;
+        if (gitShow.exit_code !== 0) {
+            editor.setStatus(editor.t("status.failed_old_version"));
+            return;
+        }
+        const oldContent = gitShow.stdout;
+
+        // Read new file content (use absolute path for readFile)
+        let newContent: string;
+        try {
+            newContent = await editor.readFile(absoluteFilePath);
+        } catch (e) {
+            editor.setStatus(editor.t("status.failed_new_version"));
+            return;
+        }
+
+        // Close the Review Diff buffer to make room for side-by-side view
+        // Store the review buffer ID so we can restore it later
+        const reviewBufferId = bid;
 
-        // Side-by-side layout: NEW (editable, left) | OLD (read-only, right)
-        // Note: Ideally OLD should be on left per convention, but API creates splits to the right
+        // Compute aligned diff for the FULL file with all hunks
+        const alignedLines = computeFullFileAlignedDiff(oldContent, newContent, fileHunks);
 
-        // Step 1: Open NEW file in current split (becomes LEFT pane)
-        editor.openFile(h.file, h.range.start, 0);
-        const newSplitId = (editor as any).getActiveSplitId();
+        // Generate content for both panes
+        const oldPane = generateDiffPaneContent(alignedLines, 'old');
+        const newPane = generateDiffPaneContent(alignedLines, 'new');
 
-        // Step 2: Create OLD (HEAD) version in new split (becomes RIGHT pane)
-        // editing_disabled: true prevents text input in read-only buffer
-        const oldRes = await editor.createVirtualBufferInSplit({
-            name: `[OLD ◀] ${h.file}`,  // Arrow indicates this is the old/reference version
-            mode: "special",
+        // Close any existing side-by-side views
+        if (activeSideBySideState) {
+            try {
+                // Remove scroll sync group first
+                if (activeSideBySideState.scrollSyncGroupId !== null) {
+                    (editor as any).removeScrollSyncGroup(activeSideBySideState.scrollSyncGroupId);
+                }
+                editor.closeBuffer(activeSideBySideState.oldBufferId);
+                editor.closeBuffer(activeSideBySideState.newBufferId);
+            } catch {}
+            activeSideBySideState = null;
+        }
+
+        // Get the current split ID before closing the Review Diff buffer
+        const currentSplitId = (editor as any).getActiveSplitId();
+
+        // Create OLD buffer in the CURRENT split (replaces Review Diff)
+        const oldBufferId = await editor.createVirtualBufferInExistingSplit({
+            name: `[OLD] ${h.file}`,
+            mode: "diff-view",
             read_only: true,
             editing_disabled: true,
-            entries: [{ text: gitShow.stdout, properties: {} }],
+            entries: oldPane.entries,
+            split_id: currentSplitId,
+            show_line_numbers: false,
+            line_wrap: false
+        });
+        const oldSplitId = currentSplitId;
+
+        // Close the Review Diff buffer after showing OLD
+        editor.closeBuffer(reviewBufferId);
+
+        // Apply highlights to old pane
+        editor.clearNamespace(oldBufferId, "diff-view");
+        for (const hl of oldPane.highlights) {
+            const bg = hl.bg || [-1, -1, -1];
+            editor.addOverlay(
+                oldBufferId, "diff-view",
+                hl.range[0], hl.range[1],
+                hl.fg[0], hl.fg[1], hl.fg[2],
+                false, hl.bold || false, false,
+                bg[0], bg[1], bg[2],
+                hl.extend_to_line_end || false
+            );
+        }
+
+        // Step 2: Create NEW pane in a vertical split (RIGHT of OLD)
+        const newRes = await editor.createVirtualBufferInSplit({
+            name: `[NEW] ${h.file}`,
+            mode: "diff-view",
+            read_only: true,
+            editing_disabled: true,
+            entries: newPane.entries,
             ratio: 0.5,
             direction: "vertical",
-            show_line_numbers: true
+            show_line_numbers: false,
+            line_wrap: false
         });
-        const oldSplitId = oldRes.split_id!;
+        const newBufferId = newRes.buffer_id;
+        const newSplitId = newRes.split_id!;
+
+        // Apply highlights to new pane
+        editor.clearNamespace(newBufferId, "diff-view");
+        for (const hl of newPane.highlights) {
+            const bg = hl.bg || [-1, -1, -1];
+            editor.addOverlay(
+                newBufferId, "diff-view",
+                hl.range[0], hl.range[1],
+                hl.fg[0], hl.fg[1], hl.fg[2],
+                false, hl.bold || false, false,
+                bg[0], bg[1], bg[2],
+                hl.extend_to_line_end || false
+            );
+        }
 
-        // Focus on NEW (left) pane - this is the editable working version
-        (editor as any).focusSplit(newSplitId);
+        // Focus OLD pane (left) - convention is to start on old side
+        (editor as any).focusSplit(oldSplitId);
+
+        // Set up core-handled scroll sync using the new anchor-based API
+        // This replaces the old viewport_changed hook approach
+        let scrollSyncGroupId: number | null = null;
+        try {
+            // Generate a unique group ID
+            scrollSyncGroupId = nextScrollSyncGroupId++;
+            (editor as any).createScrollSyncGroup(scrollSyncGroupId, oldSplitId, newSplitId);
+
+            // Compute sync anchors from aligned lines
+            // Each aligned line is a sync point - we map line indices to anchors
+            // For the new core sync, we use line numbers (not byte offsets)
+            const anchors: [number, number][] = [];
+            for (let i = 0; i < alignedLines.length; i++) {
+                // Add anchors at meaningful boundaries: start of file, and at change boundaries
+                const line = alignedLines[i];
+                const prevLine = i > 0 ? alignedLines[i - 1] : null;
+
+                // Add anchor at start of file
+                if (i === 0) {
+                    anchors.push([0, 0]);
+                }
 
-        // Track splits for synchronized scrolling
-        activeDiffViewState = { lSplit: newSplitId, rSplit: oldSplitId };
-        editor.on("viewport_changed", "on_viewport_changed");
+                // Add anchor at change boundaries (when change type changes)
+                if (prevLine && prevLine.changeType !== line.changeType) {
+                    anchors.push([i, i]);
+                }
+            }
+
+            // Add anchor at end
+            if (alignedLines.length > 0) {
+                anchors.push([alignedLines.length, alignedLines.length]);
+            }
+
+            (editor as any).setScrollSyncAnchors(scrollSyncGroupId, anchors);
+        } catch (e) {
+            editor.debug(`Failed to create scroll sync group: ${e}`);
+            scrollSyncGroupId = null;
+        }
+
+        // Store state for synchronized scrolling
+        activeSideBySideState = {
+            oldSplitId,
+            newSplitId,
+            oldBufferId,
+            newBufferId,
+            alignedLines,
+            oldLineByteOffsets: oldPane.lineByteOffsets,
+            newLineByteOffsets: newPane.lineByteOffsets,
+            scrollSyncGroupId
+        };
+        activeDiffViewState = { lSplit: oldSplitId, rSplit: newSplitId };
+
+        const addedLines = alignedLines.filter(l => l.changeType === 'added').length;
+        const removedLines = alignedLines.filter(l => l.changeType === 'removed').length;
+        const modifiedLines = alignedLines.filter(l => l.changeType === 'modified').length;
+        editor.setStatus(editor.t("status.diff_summary", { added: String(addedLines), removed: String(removedLines), modified: String(modifiedLines) }));
     }
 };
 
+// Define the diff-view mode with navigation keys
+editor.defineMode("diff-view", "special", [
+    ["q", "close_buffer"],
+    ["j", "move_down"],
+    ["k", "move_up"],
+    ["g", "move_document_start"],
+    ["G", "move_document_end"],
+    ["Ctrl+d", "move_page_down"],
+    ["Ctrl+u", "move_page_up"],
+    ["Down", "move_down"],
+    ["Up", "move_up"],
+    ["PageDown", "move_page_down"],
+    ["PageUp", "move_page_up"],
+], true);
+
 // --- Review Comment Actions ---
 
 function getCurrentHunkId(): string | null {
@@ -728,7 +1252,7 @@ let pendingCommentInfo: PendingCommentInfo | null = null;
 globalThis.review_add_comment = async () => {
     const info = getCurrentLineInfo();
     if (!info) {
-        editor.setStatus("No hunk selected for comment");
+        editor.setStatus(editor.t("status.no_hunk_selected"));
         return;
     }
     pendingCommentInfo = info;
@@ -744,7 +1268,7 @@ globalThis.review_add_comment = async () => {
     } else if (info.oldLine) {
         lineRef = `L${info.oldLine}`;
     }
-    editor.startPrompt(`Comment on ${lineRef}: `, "review-comment");
+    editor.startPrompt(editor.t("prompt.comment", { line: lineRef }), "review-comment");
 };
 
 // Prompt event handlers
@@ -776,7 +1300,7 @@ globalThis.on_review_prompt_confirm = (args: { prompt_type: string; input: strin
         } else if (comment.old_line) {
             lineRef = `line ${comment.old_line}`;
         }
-        editor.setStatus(`Comment added to ${lineRef}`);
+        editor.setStatus(editor.t("status.comment_added", { line: lineRef }));
     }
     pendingCommentInfo = null;
     return true;
@@ -785,7 +1309,7 @@ globalThis.on_review_prompt_confirm = (args: { prompt_type: string; input: strin
 globalThis.on_review_prompt_cancel = (args: { prompt_type: string }): boolean => {
     if (args.prompt_type === "review-comment") {
         pendingCommentInfo = null;
-        editor.setStatus("Comment cancelled");
+        editor.setStatus(editor.t("status.comment_cancelled"));
     }
     return true;
 };
@@ -801,7 +1325,7 @@ globalThis.review_approve_hunk = async () => {
     if (h) {
         h.reviewStatus = 'approved';
         await updateReviewUI();
-        editor.setStatus(`Hunk approved`);
+        editor.setStatus(editor.t("status.hunk_approved"));
     }
 };
 
@@ -812,7 +1336,7 @@ globalThis.review_reject_hunk = async () => {
     if (h) {
         h.reviewStatus = 'rejected';
         await updateReviewUI();
-        editor.setStatus(`Hunk rejected`);
+        editor.setStatus(editor.t("status.hunk_rejected"));
     }
 };
 
@@ -823,7 +1347,7 @@ globalThis.review_needs_changes = async () => {
     if (h) {
         h.reviewStatus = 'needs_changes';
         await updateReviewUI();
-        editor.setStatus(`Hunk marked as needs changes`);
+        editor.setStatus(editor.t("status.hunk_needs_changes"));
     }
 };
 
@@ -834,7 +1358,7 @@ globalThis.review_question_hunk = async () => {
     if (h) {
         h.reviewStatus = 'question';
         await updateReviewUI();
-        editor.setStatus(`Hunk marked with question`);
+        editor.setStatus(editor.t("status.hunk_question"));
     }
 };
 
@@ -845,15 +1369,15 @@ globalThis.review_clear_status = async () => {
     if (h) {
         h.reviewStatus = 'pending';
         await updateReviewUI();
-        editor.setStatus(`Hunk review status cleared`);
+        editor.setStatus(editor.t("status.hunk_status_cleared"));
     }
 };
 
 globalThis.review_set_overall_feedback = async () => {
-    const text = await editor.prompt("Overall feedback: ", state.overallFeedback || "");
+    const text = await editor.prompt(editor.t("prompt.overall_feedback"), state.overallFeedback || "");
     if (text !== null) {
         state.overallFeedback = text.trim();
-        editor.setStatus(`Overall feedback ${text.trim() ? 'set' : 'cleared'}`);
+        editor.setStatus(text.trim() ? editor.t("status.feedback_set") : editor.t("status.feedback_cleared"));
     }
 };
 
@@ -861,10 +1385,7 @@ globalThis.review_export_session = async () => {
     const cwd = editor.getCwd();
     const reviewDir = editor.pathJoin(cwd, ".review");
 
-    // Create .review directory if needed
-    await editor.spawnProcess("mkdir", ["-p", reviewDir]);
-
-    // Generate markdown content
+    // Generate markdown content (writeFile creates parent directories)
     let md = `# Code Review Session\n`;
     md += `Date: ${new Date().toISOString()}\n\n`;
 
@@ -930,13 +1451,13 @@ globalThis.review_export_session = async () => {
     // Write file
     const filePath = editor.pathJoin(reviewDir, "session.md");
     await editor.writeFile(filePath, md);
-    editor.setStatus(`Review exported to ${filePath}`);
+    editor.setStatus(editor.t("status.exported", { path: filePath }));
 };
 
 globalThis.review_export_json = async () => {
     const cwd = editor.getCwd();
     const reviewDir = editor.pathJoin(cwd, ".review");
-    await editor.spawnProcess("mkdir", ["-p", reviewDir]);
+    // writeFile creates parent directories
 
     const session = {
         version: "1.0",
@@ -966,11 +1487,11 @@ globalThis.review_export_json = async () => {
 
     const filePath = editor.pathJoin(reviewDir, "session.json");
     await editor.writeFile(filePath, JSON.stringify(session, null, 2));
-    editor.setStatus(`Review exported to ${filePath}`);
+    editor.setStatus(editor.t("status.exported", { path: filePath }));
 };
 
 globalThis.start_review_diff = async () => {
-    editor.setStatus("Generating Review Diff Stream...");
+    editor.setStatus(editor.t("status.generating"));
     editor.setContext("review-mode", true);
 
     // Initial data fetch
@@ -985,7 +1506,7 @@ globalThis.start_review_diff = async () => {
     state.reviewBufferId = bufferId;
     await updateReviewUI(); // Apply initial highlights
 
-    editor.setStatus(`Review Diff: ${state.hunks.length} hunks | [c]omment [a]pprove [x]reject [!]changes [?]question [E]xport`);
+    editor.setStatus(editor.t("status.review_summary", { count: String(state.hunks.length) }));
     editor.on("buffer_activated", "on_review_buffer_activated");
     editor.on("buffer_closed", "on_review_buffer_closed");
 };
@@ -995,9 +1516,10 @@ globalThis.stop_review_diff = () => {
     editor.setContext("review-mode", false);
     editor.off("buffer_activated", "on_review_buffer_activated");
     editor.off("buffer_closed", "on_review_buffer_closed");
-    editor.setStatus("Review Diff Mode stopped.");
+    editor.setStatus(editor.t("status.stopped"));
 };
 
+
 globalThis.on_review_buffer_activated = (data: any) => {
     if (data.buffer_id === state.reviewBufferId) refreshReviewData();
 };
@@ -1006,21 +1528,267 @@ globalThis.on_review_buffer_closed = (data: any) => {
     if (data.buffer_id === state.reviewBufferId) stop_review_diff();
 };
 
+// Side-by-side diff for current file (can be called directly without Review Diff mode)
+globalThis.side_by_side_diff_current_file = async () => {
+    const bid = editor.getActiveBufferId();
+    const absolutePath = editor.getBufferPath(bid);
+
+    if (!absolutePath) {
+        editor.setStatus(editor.t("status.no_file_open"));
+        return;
+    }
+
+    editor.setStatus(editor.t("status.loading_diff"));
+
+    // Get the file's directory and name for running git commands
+    const fileDir = editor.pathDirname(absolutePath);
+    const fileName = editor.pathBasename(absolutePath);
+
+    // Run git commands from the file's directory to avoid path format issues on Windows
+    const gitRootResult = await editor.spawnProcess("git", ["-C", fileDir, "rev-parse", "--show-toplevel"]);
+    if (gitRootResult.exit_code !== 0) {
+        editor.setStatus(editor.t("status.not_git_repo"));
+        return;
+    }
+    const gitRoot = gitRootResult.stdout.trim();
+
+    // Get relative path from git root using git itself (handles Windows paths correctly)
+    const relPathResult = await editor.spawnProcess("git", ["-C", fileDir, "ls-files", "--full-name", fileName]);
+    let filePath: string;
+    if (relPathResult.exit_code === 0 && relPathResult.stdout.trim()) {
+        filePath = relPathResult.stdout.trim();
+    } else {
+        // File might be untracked, compute relative path manually
+        // Normalize paths: replace backslashes with forward slashes for comparison
+        const normAbsPath = absolutePath.replace(/\\/g, '/');
+        const normGitRoot = gitRoot.replace(/\\/g, '/');
+        if (normAbsPath.toLowerCase().startsWith(normGitRoot.toLowerCase())) {
+            filePath = normAbsPath.substring(normGitRoot.length + 1);
+        } else {
+            // Fallback to just the filename
+            filePath = fileName;
+        }
+    }
+
+    // Get hunks for this specific file (use -C gitRoot since filePath is relative to git root)
+    const result = await editor.spawnProcess("git", ["-C", gitRoot, "diff", "HEAD", "--unified=3", "--", filePath]);
+    if (result.exit_code !== 0) {
+        editor.setStatus(editor.t("status.failed_git_diff"));
+        return;
+    }
+
+    // Parse hunks from diff output
+    const lines = result.stdout.split('\n');
+    const fileHunks: Hunk[] = [];
+    let currentHunk: Hunk | null = null;
+
+    for (const line of lines) {
+        if (line.startsWith('@@')) {
+            const match = line.match(/@@ -(\d+),?\d* \+(\d+),?\d* @@(.*)/);
+            if (match) {
+                const oldStart = parseInt(match[1]);
+                const newStart = parseInt(match[2]);
+                currentHunk = {
+                    id: `${filePath}:${newStart}`,
+                    file: filePath,
+                    range: { start: newStart, end: newStart },
+                    oldRange: { start: oldStart, end: oldStart },
+                    type: 'modify',
+                    lines: [],
+                    status: 'pending',
+                    reviewStatus: 'pending',
+                    contextHeader: match[3]?.trim() || "",
+                    byteOffset: 0
+                };
+                fileHunks.push(currentHunk);
+            }
+        } else if (currentHunk && (line.startsWith('+') || line.startsWith('-') || line.startsWith(' '))) {
+            if (!line.startsWith('---') && !line.startsWith('+++')) {
+                currentHunk.lines.push(line);
+            }
+        }
+    }
+
+    if (fileHunks.length === 0) {
+        editor.setStatus(editor.t("status.no_changes"));
+        return;
+    }
+
+    // Get old (HEAD) and new (working) file content (use -C gitRoot since filePath is relative to git root)
+    const gitShow = await editor.spawnProcess("git", ["-C", gitRoot, "show", `HEAD:${filePath}`]);
+    if (gitShow.exit_code !== 0) {
+        editor.setStatus(editor.t("status.failed_old_new_file"));
+        return;
+    }
+    const oldContent = gitShow.stdout;
+
+    // Read new file content (use absolute path for readFile)
+    let newContent: string;
+    try {
+        newContent = await editor.readFile(absolutePath);
+    } catch (e) {
+        editor.setStatus(editor.t("status.failed_new_version"));
+        return;
+    }
+
+    // Compute aligned diff for the FULL file
+    const alignedLines = computeFullFileAlignedDiff(oldContent, newContent, fileHunks);
+
+    // Generate content for both panes
+    const oldPane = generateDiffPaneContent(alignedLines, 'old');
+    const newPane = generateDiffPaneContent(alignedLines, 'new');
+
+    // Close any existing side-by-side views
+    if (activeSideBySideState) {
+        try {
+            if (activeSideBySideState.scrollSyncGroupId !== null) {
+                (editor as any).removeScrollSyncGroup(activeSideBySideState.scrollSyncGroupId);
+            }
+            editor.closeBuffer(activeSideBySideState.oldBufferId);
+            editor.closeBuffer(activeSideBySideState.newBufferId);
+        } catch {}
+        activeSideBySideState = null;
+    }
+
+    // Get the current split ID
+    const currentSplitId = (editor as any).getActiveSplitId();
+
+    // Create OLD buffer in the CURRENT split
+    const oldBufferId = await editor.createVirtualBufferInExistingSplit({
+        name: `[OLD] ${filePath}`,
+        mode: "diff-view",
+        read_only: true,
+        editing_disabled: true,
+        entries: oldPane.entries,
+        split_id: currentSplitId,
+        show_line_numbers: false,
+        line_wrap: false
+    });
+    const oldSplitId = currentSplitId;
+
+    // Apply highlights to old pane
+    editor.clearNamespace(oldBufferId, "diff-view");
+    for (const hl of oldPane.highlights) {
+        const bg = hl.bg || [-1, -1, -1];
+        editor.addOverlay(
+            oldBufferId, "diff-view",
+            hl.range[0], hl.range[1],
+            hl.fg[0], hl.fg[1], hl.fg[2],
+            false, hl.bold || false, false,
+            bg[0], bg[1], bg[2],
+            hl.extend_to_line_end || false
+        );
+    }
+
+    // Create NEW pane in a vertical split (RIGHT of OLD)
+    const newRes = await editor.createVirtualBufferInSplit({
+        name: `[NEW] ${filePath}`,
+        mode: "diff-view",
+        read_only: true,
+        editing_disabled: true,
+        entries: newPane.entries,
+        ratio: 0.5,
+        direction: "vertical",
+        show_line_numbers: false,
+        line_wrap: false
+    });
+    const newBufferId = newRes.buffer_id;
+    const newSplitId = newRes.split_id!;
+
+    // Apply highlights to new pane
+    editor.clearNamespace(newBufferId, "diff-view");
+    for (const hl of newPane.highlights) {
+        const bg = hl.bg || [-1, -1, -1];
+        editor.addOverlay(
+            newBufferId, "diff-view",
+            hl.range[0], hl.range[1],
+            hl.fg[0], hl.fg[1], hl.fg[2],
+            false, hl.bold || false, false,
+            bg[0], bg[1], bg[2],
+            hl.extend_to_line_end || false
+        );
+    }
+
+    // Focus OLD pane (left)
+    (editor as any).focusSplit(oldSplitId);
+
+    // Set up scroll sync
+    let scrollSyncGroupId: number | null = null;
+    try {
+        scrollSyncGroupId = nextScrollSyncGroupId++;
+        (editor as any).createScrollSyncGroup(scrollSyncGroupId, oldSplitId, newSplitId);
+
+        const anchors: [number, number][] = [];
+        for (let i = 0; i < alignedLines.length; i++) {
+            const line = alignedLines[i];
+            const prevLine = i > 0 ? alignedLines[i - 1] : null;
+            if (i === 0) anchors.push([0, 0]);
+            if (prevLine && prevLine.changeType !== line.changeType) {
+                anchors.push([i, i]);
+            }
+        }
+        if (alignedLines.length > 0) {
+            anchors.push([alignedLines.length, alignedLines.length]);
+        }
+        (editor as any).setScrollSyncAnchors(scrollSyncGroupId, anchors);
+    } catch (e) {
+        editor.debug(`Failed to create scroll sync group: ${e}`);
+        scrollSyncGroupId = null;
+    }
+
+    // Store state
+    activeSideBySideState = {
+        oldSplitId,
+        newSplitId,
+        oldBufferId,
+        newBufferId,
+        alignedLines,
+        oldLineByteOffsets: oldPane.lineByteOffsets,
+        newLineByteOffsets: newPane.lineByteOffsets,
+        scrollSyncGroupId
+    };
+    activeDiffViewState = { lSplit: oldSplitId, rSplit: newSplitId };
+
+    const addedLines = alignedLines.filter(l => l.changeType === 'added').length;
+    const removedLines = alignedLines.filter(l => l.changeType === 'removed').length;
+    const modifiedLines = alignedLines.filter(l => l.changeType === 'modified').length;
+    editor.setStatus(editor.t("status.diff_summary", { added: String(addedLines), removed: String(removedLines), modified: String(modifiedLines) }));
+};
+
 // Register Modes and Commands
-editor.registerCommand("Review Diff", "Start code review session", "start_review_diff", "global");
-editor.registerCommand("Stop Review Diff", "Stop the review session", "stop_review_diff", "review-mode");
-editor.registerCommand("Refresh Review Diff", "Refresh the list of changes", "review_refresh", "review-mode");
+editor.registerCommand("%cmd.review_diff", "%cmd.review_diff_desc", "start_review_diff", "global");
+editor.registerCommand("%cmd.stop_review_diff", "%cmd.stop_review_diff_desc", "stop_review_diff", "review-mode");
+editor.registerCommand("%cmd.refresh_review_diff", "%cmd.refresh_review_diff_desc", "review_refresh", "review-mode");
+editor.registerCommand("%cmd.side_by_side_diff", "%cmd.side_by_side_diff_desc", "side_by_side_diff_current_file", "global");
 
 // Review Comment Commands
-editor.registerCommand("Review: Add Comment", "Add a review comment to the current hunk", "review_add_comment", "review-mode");
-editor.registerCommand("Review: Approve Hunk", "Mark hunk as approved", "review_approve_hunk", "review-mode");
-editor.registerCommand("Review: Reject Hunk", "Mark hunk as rejected", "review_reject_hunk", "review-mode");
-editor.registerCommand("Review: Needs Changes", "Mark hunk as needing changes", "review_needs_changes", "review-mode");
-editor.registerCommand("Review: Question", "Mark hunk with a question", "review_question_hunk", "review-mode");
-editor.registerCommand("Review: Clear Status", "Clear hunk review status", "review_clear_status", "review-mode");
-editor.registerCommand("Review: Overall Feedback", "Set overall review feedback", "review_set_overall_feedback", "review-mode");
-editor.registerCommand("Review: Export to Markdown", "Export review to .review/session.md", "review_export_session", "review-mode");
-editor.registerCommand("Review: Export to JSON", "Export review to .review/session.json", "review_export_json", "review-mode");
+editor.registerCommand("%cmd.add_comment", "%cmd.add_comment_desc", "review_add_comment", "review-mode");
+editor.registerCommand("%cmd.approve_hunk", "%cmd.approve_hunk_desc", "review_approve_hunk", "review-mode");
+editor.registerCommand("%cmd.reject_hunk", "%cmd.reject_hunk_desc", "review_reject_hunk", "review-mode");
+editor.registerCommand("%cmd.needs_changes", "%cmd.needs_changes_desc", "review_needs_changes", "review-mode");
+editor.registerCommand("%cmd.question", "%cmd.question_desc", "review_question_hunk", "review-mode");
+editor.registerCommand("%cmd.clear_status", "%cmd.clear_status_desc", "review_clear_status", "review-mode");
+editor.registerCommand("%cmd.overall_feedback", "%cmd.overall_feedback_desc", "review_set_overall_feedback", "review-mode");
+editor.registerCommand("%cmd.export_markdown", "%cmd.export_markdown_desc", "review_export_session", "review-mode");
+editor.registerCommand("%cmd.export_json", "%cmd.export_json_desc", "review_export_json", "review-mode");
+
+// Handler for when buffers are closed - cleans up scroll sync groups
+globalThis.on_buffer_closed = (data: any) => {
+    // If one of the diff view buffers is closed, clean up the scroll sync group
+    if (activeSideBySideState) {
+        if (data.buffer_id === activeSideBySideState.oldBufferId ||
+            data.buffer_id === activeSideBySideState.newBufferId) {
+            // Remove scroll sync group
+            if (activeSideBySideState.scrollSyncGroupId !== null) {
+                try {
+                    (editor as any).removeScrollSyncGroup(activeSideBySideState.scrollSyncGroupId);
+                } catch {}
+            }
+            activeSideBySideState = null;
+            activeDiffViewState = null;
+        }
+    }
+};
 
 editor.on("buffer_closed", "on_buffer_closed");
 
@@ -1042,4 +1810,4 @@ editor.defineMode("review-mode", "normal", [
     ["E", "review_export_session"],
 ], true);
 
-editor.debug("Review Diff plugin loaded with review comments support");
+editor.debug("Review Diff plugin loaded with review comments support");