diffstalker 0.2.1 → 0.2.2

package/dist/ui/widgets/FileList.js

@@ -1,53 +1,5 @@
 import { categorizeFiles } from '../../utils/fileCategories.js';
-import { shortenPath } from '../../utils/formatPath.js';
-function getStatusChar(status) {
-    switch (status) {
-        case 'modified':
-            return 'M';
-        case 'added':
-            return 'A';
-        case 'deleted':
-            return 'D';
-        case 'untracked':
-            return '?';
-        case 'renamed':
-            return 'R';
-        case 'copied':
-            return 'C';
-        default:
-            return ' ';
-    }
-}
-function getStatusColor(status) {
-    switch (status) {
-        case 'modified':
-            return 'yellow';
-        case 'added':
-            return 'green';
-        case 'deleted':
-            return 'red';
-        case 'untracked':
-            return 'gray';
-        case 'renamed':
-            return 'blue';
-        case 'copied':
-            return 'cyan';
-        default:
-            return 'white';
-    }
-}
-function formatStats(insertions, deletions) {
-    if (insertions === undefined && deletions === undefined)
-        return '';
-    const parts = [];
-    if (insertions !== undefined && insertions > 0) {
-        parts.push(`{green-fg}+${insertions}{/green-fg}`);
-    }
-    if (deletions !== undefined && deletions > 0) {
-        parts.push(`{red-fg}-${deletions}{/red-fg}`);
-    }
-    return parts.length > 0 ? ' ' + parts.join(' ') : '';
-}
+import { getStatusChar, getStatusColor, formatStats, formatSelectionIndicator, formatFilePath, formatOriginalPath, } from './fileRowFormatters.js';
 /**
  * Build the list of row items for the file list.
  */
@@ -81,10 +33,52 @@ export function buildFileListRows(files) {
     }
     return rows;
 }
+/**
+ * Format a single file row as blessed-compatible tagged string.
+ */
+/**
+ * Format hunk count indicator for a file, e.g. "@2/3".
+ * Returns empty string if not applicable.
+ */
+function formatHunkIndicator(file, hunkCounts) {
+    if (!hunkCounts)
+        return '';
+    const stagedHunks = hunkCounts.staged.get(file.path) ?? 0;
+    const unstagedHunks = hunkCounts.unstaged.get(file.path) ?? 0;
+    const total = stagedHunks + unstagedHunks;
+    if (total === 0)
+        return '';
+    const thisCount = file.staged ? stagedHunks : unstagedHunks;
+    // Show just @total when all hunks are in this state, otherwise @n/total
+    if (thisCount === total)
+        return ` {cyan-fg}@${total}{/cyan-fg}`;
+    return ` {cyan-fg}@${thisCount}/${total}{/cyan-fg}`;
+}
+function formatFileRow(file, fileIndex, selectedIndex, isFocused, maxPathLength, hunkCounts) {
+    const isSelected = fileIndex === selectedIndex;
+    const statusChar = getStatusChar(file.status);
+    const statusColor = getStatusColor(file.status);
+    const actionButton = file.staged ? '[-]' : '[+]';
+    const buttonColor = file.staged ? 'red' : 'green';
+    // Calculate available space for path
+    const stats = formatStats(file.insertions, file.deletions);
+    const hunkIndicator = formatHunkIndicator(file, hunkCounts);
+    const statsLength = stats.replace(/\{[^}]+\}/g, '').length;
+    const hunkLength = hunkIndicator.replace(/\{[^}]+\}/g, '').length;
+    const availableForPath = maxPathLength - statsLength - hunkLength;
+    let line = formatSelectionIndicator(isSelected, isFocused);
+    line += `{${buttonColor}-fg}${actionButton}{/${buttonColor}-fg} `;
+    line += `{${statusColor}-fg}${statusChar}{/${statusColor}-fg} `;
+    line += formatFilePath(file.path, isSelected, isFocused, availableForPath);
+    line += formatOriginalPath(file.originalPath);
+    line += stats;
+    line += hunkIndicator;
+    return line;
+}
 /**
  * Format the file list as blessed-compatible tagged string.
  */
-export function formatFileList(files, selectedIndex, isFocused, width, scrollOffset = 0, maxHeight) {
+export function formatFileList(files, selectedIndex, isFocused, width, scrollOffset = 0, maxHeight, hunkCounts) {
     if (files.length === 0) {
         return '{gray-fg} No changes{/gray-fg}';
     }
@@ -95,53 +89,26 @@ export function formatFileList(files, selectedIndex, isFocused, width, scrollOff
         ? rows.slice(scrollOffset, scrollOffset + maxHeight)
         : rows.slice(scrollOffset);
     const lines = [];
+    let seenFirstHeader = false;
     for (const row of visibleRows) {
-        if (row.type === 'header') {
-            lines.push(`{bold}{${row.headerColor}-fg}${row.content}{/${row.headerColor}-fg}{/bold}`);
-        }
-        else if (row.type === 'spacer') {
-            lines.push('');
-        }
-        else if (row.type === 'file' && row.file && row.fileIndex !== undefined) {
-            const file = row.file;
-            const isSelected = row.fileIndex === selectedIndex;
-            const isHighlighted = isSelected && isFocused;
-            const statusChar = getStatusChar(file.status);
-            const statusColor = getStatusColor(file.status);
-            const actionButton = file.staged ? '[-]' : '[+]';
-            const buttonColor = file.staged ? 'red' : 'green';
-            // Calculate available space for path
-            const stats = formatStats(file.insertions, file.deletions);
-            const statsLength = stats.replace(/\{[^}]+\}/g, '').length;
-            const availableForPath = maxPathLength - statsLength;
-            const displayPath = shortenPath(file.path, availableForPath);
-            // Build the line
-            let line = '';
-            // Selection indicator
-            if (isHighlighted) {
-                line += '{cyan-fg}{bold}\u25b8 {/bold}{/cyan-fg}';
-            }
-            else {
-                line += '  ';
-            }
-            // Action button
-            line += `{${buttonColor}-fg}${actionButton}{/${buttonColor}-fg} `;
-            // Status character
-            line += `{${statusColor}-fg}${statusChar}{/${statusColor}-fg} `;
-            // File path (with highlighting)
-            if (isHighlighted) {
-                line += `{cyan-fg}{inverse}${displayPath}{/inverse}{/cyan-fg}`;
-            }
-            else {
-                line += displayPath;
-            }
-            // Original path for renames
-            if (file.originalPath) {
-                line += ` {gray-fg}\u2190 ${shortenPath(file.originalPath, 30)}{/gray-fg}`;
+        switch (row.type) {
+            case 'header': {
+                let headerLine = `{bold}{${row.headerColor}-fg}${row.content}{/${row.headerColor}-fg}{/bold}`;
+                if (!seenFirstHeader) {
+                    seenFirstHeader = true;
+                    headerLine += ' {gray-fg}(h:flat){/gray-fg}';
+                }
+                lines.push(headerLine);
+                break;
             }
-            // Stats
-            line += stats;
-            lines.push(line);
+            case 'spacer':
+                lines.push('');
+                break;
+            case 'file':
+                if (row.file && row.fileIndex !== undefined) {
+                    lines.push(formatFileRow(row.file, row.fileIndex, selectedIndex, isFocused, maxPathLength, hunkCounts ?? null));
+                }
+                break;
         }
     }
     return lines.join('\n');

package/dist/ui/widgets/FlatFileList.js

@@ -0,0 +1,65 @@
+import { getStatusChar, getStatusColor, formatStats, formatSelectionIndicator, formatFilePath, formatOriginalPath, } from './fileRowFormatters.js';
+function getStagingButton(state) {
+    switch (state) {
+        case 'unstaged':
+            return { text: '[+]', color: 'green' };
+        case 'staged':
+            return { text: '[-]', color: 'red' };
+        case 'partial':
+            return { text: '[~]', color: 'yellow' };
+    }
+}
+function formatFlatHunkIndicator(entry) {
+    if (entry.totalHunks === 0)
+        return '';
+    // Always show staged/total in flat view
+    return ` {cyan-fg}@${entry.stagedHunks}/${entry.totalHunks}{/cyan-fg}`;
+}
+function formatFlatFileRow(entry, index, selectedIndex, isFocused, maxPathLength) {
+    const isSelected = index === selectedIndex;
+    const statusChar = getStatusChar(entry.status);
+    const statusColor = getStatusColor(entry.status);
+    const button = getStagingButton(entry.stagingState);
+    const stats = formatStats(entry.insertions, entry.deletions);
+    const hunkIndicator = formatFlatHunkIndicator(entry);
+    const statsLength = stats.replace(/\{[^}]+\}/g, '').length;
+    const hunkLength = hunkIndicator.replace(/\{[^}]+\}/g, '').length;
+    const availableForPath = maxPathLength - statsLength - hunkLength;
+    let line = formatSelectionIndicator(isSelected, isFocused);
+    line += `{${button.color}-fg}${button.text}{/${button.color}-fg} `;
+    line += `{${statusColor}-fg}${statusChar}{/${statusColor}-fg} `;
+    line += formatFilePath(entry.path, isSelected, isFocused, availableForPath);
+    line += formatOriginalPath(entry.originalPath);
+    line += stats;
+    line += hunkIndicator;
+    return line;
+}
+/**
+ * Format the flat file list as blessed-compatible tagged string.
+ * Row 0 is a header; files start at row 1.
+ */
+export function formatFlatFileList(flatFiles, selectedIndex, isFocused, width, scrollOffset = 0, maxHeight) {
+    if (flatFiles.length === 0) {
+        return '{gray-fg} No changes{/gray-fg}';
+    }
+    const maxPathLength = width - 12;
+    // Build all rows: header + file rows
+    const allRows = [];
+    allRows.push('{bold}{gray-fg}All files (h):{/gray-fg}{/bold}');
+    for (let i = 0; i < flatFiles.length; i++) {
+        allRows.push(formatFlatFileRow(flatFiles[i], i, selectedIndex, isFocused, maxPathLength));
+    }
+    // Apply scroll offset and max height
+    const visibleRows = maxHeight
+        ? allRows.slice(scrollOffset, scrollOffset + maxHeight)
+        : allRows.slice(scrollOffset);
+    return visibleRows.join('\n');
+}
+/**
+ * Total rows in the flat file list (header + files).
+ */
+export function getFlatFileListTotalRows(flatFiles) {
+    if (flatFiles.length === 0)
+        return 0;
+    return flatFiles.length + 1; // +1 for header
+}

package/dist/ui/widgets/Footer.js

@@ -4,26 +4,36 @@
 function calculateVisibleLength(content) {
     return content.replace(/\{[^}]+\}/g, '').length;
 }
+/**
+ * Format a toggle indicator: blue when on, gray when off.
+ */
+function toggleIndicator(label, enabled) {
+    return enabled ? `{blue-fg}[${label}]{/blue-fg}` : `{gray-fg}[${label}]{/gray-fg}`;
+}
+/**
+ * Build the left-side indicators for the standard (non-hunk) footer.
+ */
+function buildStandardIndicators(mouseEnabled, autoTabEnabled, wrapMode, followEnabled, showOnlyChanges, activeTab) {
+    const parts = [];
+    parts.push(mouseEnabled ? '{yellow-fg}[scroll]{/yellow-fg}' : '{yellow-fg}m:[select]{/yellow-fg}');
+    parts.push(toggleIndicator('auto', autoTabEnabled));
+    parts.push(toggleIndicator('wrap', wrapMode));
+    parts.push(toggleIndicator('follow', followEnabled));
+    if (activeTab === 'explorer') {
+        parts.push(toggleIndicator('changes', showOnlyChanges));
+    }
+    return parts.join(' ');
+}
 /**
  * Format footer content as blessed-compatible tagged string.
  */
-export function formatFooter(activeTab, mouseEnabled, autoTabEnabled, wrapMode, followEnabled, showOnlyChanges, width) {
+export function formatFooter(activeTab, mouseEnabled, autoTabEnabled, wrapMode, followEnabled, showOnlyChanges, width, currentPane) {
     // Left side: indicators
     let leftContent = '{gray-fg}?{/gray-fg} ';
-    leftContent += mouseEnabled
-        ? '{yellow-fg}[scroll]{/yellow-fg}'
-        : '{yellow-fg}m:[select]{/yellow-fg}';
-    leftContent += ' ';
-    leftContent += autoTabEnabled ? '{blue-fg}[auto]{/blue-fg}' : '{gray-fg}[auto]{/gray-fg}';
-    leftContent += ' ';
-    leftContent += wrapMode ? '{blue-fg}[wrap]{/blue-fg}' : '{gray-fg}[wrap]{/gray-fg}';
-    leftContent += ' ';
-    leftContent += followEnabled ? '{blue-fg}[follow]{/blue-fg}' : '{gray-fg}[follow]{/gray-fg}';
-    if (activeTab === 'explorer') {
-        leftContent += ' ';
-        leftContent += showOnlyChanges
-            ? '{blue-fg}[changes]{/blue-fg}'
-            : '{gray-fg}[changes]{/gray-fg}';
+    leftContent += buildStandardIndicators(mouseEnabled, autoTabEnabled, wrapMode, followEnabled, showOnlyChanges, activeTab);
+    // Show hunk key hints when diff pane is focused on diff tab
+    if (activeTab === 'diff' && currentPane === 'diff') {
+        leftContent += ' {gray-fg}n/N:hunk s:toggle{/gray-fg}';
     }
     // Right side: tabs
     const tabs = [

package/dist/ui/widgets/Header.js

@@ -22,6 +22,19 @@ function formatBranch(branch) {
     }
     return result;
 }
+function computeBranchVisibleLength(branch) {
+    let len = branch.current.length;
+    if (branch.tracking) {
+        len += 3 + branch.tracking.length;
+    }
+    if (branch.ahead > 0) {
+        len += 3 + String(branch.ahead).length;
+    }
+    if (branch.behind > 0) {
+        len += 3 + String(branch.behind).length;
+    }
+    return len;
+}
 /**
  * Format header content as blessed-compatible tagged string.
  */
@@ -55,12 +68,7 @@ export function formatHeader(repoPath, branch, isLoading, error, width) {
         else if (error) {
             leftLen += error.length + 3; // " (error)"
         }
-        const rightLen = branch
-            ? branch.current.length +
-                (branch.tracking ? 3 + branch.tracking.length : 0) +
-                (branch.ahead > 0 ? 3 + String(branch.ahead).length : 0) +
-                (branch.behind > 0 ? 3 + String(branch.behind).length : 0)
-            : 0;
+        const rightLen = branch ? computeBranchVisibleLength(branch) : 0;
         const padding = Math.max(1, width - leftLen - rightLen - 2);
         return leftContent + ' '.repeat(padding) + rightContent;
     }

package/dist/ui/widgets/fileRowFormatters.js

@@ -0,0 +1,73 @@
+import { shortenPath } from '../../utils/formatPath.js';
+export function getStatusChar(status) {
+    switch (status) {
+        case 'modified':
+            return 'M';
+        case 'added':
+            return 'A';
+        case 'deleted':
+            return 'D';
+        case 'untracked':
+            return '?';
+        case 'renamed':
+            return 'R';
+        case 'copied':
+            return 'C';
+        default:
+            return ' ';
+    }
+}
+export function getStatusColor(status) {
+    switch (status) {
+        case 'modified':
+            return 'yellow';
+        case 'added':
+            return 'green';
+        case 'deleted':
+            return 'red';
+        case 'untracked':
+            return 'gray';
+        case 'renamed':
+            return 'blue';
+        case 'copied':
+            return 'cyan';
+        default:
+            return 'white';
+    }
+}
+export function formatStats(insertions, deletions) {
+    if (insertions === undefined && deletions === undefined)
+        return '';
+    const parts = [];
+    if (insertions !== undefined && insertions > 0) {
+        parts.push(`{green-fg}+${insertions}{/green-fg}`);
+    }
+    if (deletions !== undefined && deletions > 0) {
+        parts.push(`{red-fg}-${deletions}{/red-fg}`);
+    }
+    return parts.length > 0 ? ' ' + parts.join(' ') : '';
+}
+export function formatSelectionIndicator(isSelected, isFocused) {
+    if (isSelected && isFocused) {
+        return '{cyan-fg}{bold}\u25b8 {/bold}{/cyan-fg}';
+    }
+    else if (isSelected) {
+        return '{gray-fg}\u25b8 {/gray-fg}';
+    }
+    return '  ';
+}
+export function formatFilePath(path, isSelected, isFocused, maxLength) {
+    const displayPath = shortenPath(path, maxLength);
+    if (isSelected && isFocused) {
+        return `{cyan-fg}{inverse}${displayPath}{/inverse}{/cyan-fg}`;
+    }
+    else if (isSelected) {
+        return `{cyan-fg}${displayPath}{/cyan-fg}`;
+    }
+    return displayPath;
+}
+export function formatOriginalPath(originalPath) {
+    if (!originalPath)
+        return '';
+    return ` {gray-fg}\u2190 ${shortenPath(originalPath, 30)}{/gray-fg}`;
+}

package/dist/utils/ansiTruncate.js

@@ -85,7 +85,6 @@ export function truncateAnsi(str, maxVisualLength, suffix = '…') {
             else {
                 // Partial fit - truncate this segment
                 result += segment.content.slice(0, remainingSpace);
-                currentVisualLength += remainingSpace;
                 truncated = true;
                 break;
             }

package/dist/utils/displayRows.js

@@ -4,7 +4,7 @@ import { formatDateAbsolute } from './formatDate.js';
 import { isDisplayableDiffLine } from './diffFilters.js';
 import { breakLine, getLineRowCount } from './lineBreaking.js';
 import { computeWordDiff, areSimilarEnough } from './wordDiff.js';
-import { getLanguageFromPath, highlightBlockPreserveBg, } from './languageDetection.js';
+import { getLanguageFromPath, highlightBlockPreserveBg } from './languageDetection.js';
 /**
  * Get the text content from a diff line (strip leading +/-/space and control chars)
  */
@@ -73,8 +73,7 @@ export function buildDiffDisplayRows(diff) {
     const rows = [];
     const fileSections = [];
     let currentSection = null;
-    // Phase 1: Build display rows WITHOUT highlighting
-    // Also collect content for block highlighting
+    // Phase 1: Build display rows and collect content streams per file section
     let i = 0;
     while (i < filteredLines.length) {
         const line = filteredLines[i];
@@ -82,13 +81,10 @@ export function buildDiffDisplayRows(diff) {
         if (line.type === 'header') {
             const filePath = extractFilePathFromHeader(line.content);
             if (filePath) {
-                // Save previous section if any
                 if (currentSection) {
                     fileSections.push(currentSection);
-                    // Add spacer between files for visual separation
                     rows.push({ type: 'spacer' });
                 }
-                // Start new section
                 currentSection = {
                     language: getLanguageFromPath(filePath),
                     startRowIndex: rows.length,
@@ -102,7 +98,6 @@ export function buildDiffDisplayRows(diff) {
             i++;
             continue;
         }
-        // Hunks - just convert (don't highlight)
         if (line.type === 'hunk') {
             rows.push(convertDiffLineToDisplayRow(line));
             i++;
@@ -117,7 +112,6 @@ export function buildDiffDisplayRows(diff) {
                 lineNum: line.oldLineNum ?? line.newLineNum,
                 content,
             });
-            // Context appears in both old and new streams
             if (currentSection && currentSection.language) {
                 currentSection.oldContent.push(content);
                 currentSection.oldRowIndices.push(rowIndex);
@@ -139,22 +133,19 @@ export function buildDiffDisplayRows(diff) {
             additions.push(filteredLines[i]);
             i++;
         }
-        // Build arrays to store word diff segments for paired lines
+        // Pair deletions with additions for word-level diff
         const delSegmentsMap = new Map();
         const addSegmentsMap = new Map();
-        // Pair deletions with additions for word-level diff (only if similar enough)
         const pairCount = Math.min(deletions.length, additions.length);
         for (let j = 0; j < pairCount; j++) {
             const delContent = getLineContent(deletions[j]);
             const addContent = getLineContent(additions[j]);
-            // Only compute word diff if lines are similar enough
             if (areSimilarEnough(delContent, addContent)) {
                 const { oldSegments, newSegments } = computeWordDiff(delContent, addContent);
                 delSegmentsMap.set(j, oldSegments);
                 addSegmentsMap.set(j, newSegments);
             }
         }
-        // Output deletions first (preserving original diff order)
         for (let j = 0; j < deletions.length; j++) {
             const delLine = deletions[j];
             const delContent = getLineContent(delLine);
@@ -166,13 +157,11 @@ export function buildDiffDisplayRows(diff) {
                 content: delContent,
                 ...(segments && { wordDiffSegments: segments }),
             });
-            // Add to old stream (only if no word-diff, as word-diff takes priority)
             if (currentSection && currentSection.language && !segments) {
                 currentSection.oldContent.push(delContent);
                 currentSection.oldRowIndices.push(rowIndex);
             }
         }
-        // Then output additions
         for (let j = 0; j < additions.length; j++) {
             const addLine = additions[j];
             const addContent = getLineContent(addLine);
@@ -184,14 +173,12 @@ export function buildDiffDisplayRows(diff) {
                 content: addContent,
                 ...(segments && { wordDiffSegments: segments }),
             });
-            // Add to new stream (only if no word-diff, as word-diff takes priority)
             if (currentSection && currentSection.language && !segments) {
                 currentSection.newContent.push(addContent);
                 currentSection.newRowIndices.push(rowIndex);
             }
         }
     }
-    // Save final section
     if (currentSection) {
         fileSections.push(currentSection);
     }
@@ -199,14 +186,12 @@ export function buildDiffDisplayRows(diff) {
     for (const section of fileSections) {
         if (!section.language)
             continue;
-        // Highlight old stream (context + deletions)
         if (section.oldContent.length > 0) {
             const oldHighlighted = highlightBlockPreserveBg(section.oldContent, section.language);
             for (let j = 0; j < section.oldRowIndices.length; j++) {
                 const rowIndex = section.oldRowIndices[j];
                 const row = rows[rowIndex];
                 const highlighted = oldHighlighted[j];
-                // Only set highlighted if it's different from content
                 if (highlighted &&
                     highlighted !== row.content &&
                     (row.type === 'diff-del' || row.type === 'diff-context')) {
@@ -214,15 +199,12 @@ export function buildDiffDisplayRows(diff) {
                 }
             }
         }
-        // Highlight new stream (context + additions)
         if (section.newContent.length > 0) {
             const newHighlighted = highlightBlockPreserveBg(section.newContent, section.language);
             for (let j = 0; j < section.newRowIndices.length; j++) {
                 const rowIndex = section.newRowIndices[j];
                 const row = rows[rowIndex];
                 const highlighted = newHighlighted[j];
-                // Only set highlighted if it's different from content
-                // Note: context lines appear in both streams, but result should be same
                 if (highlighted &&
                     highlighted !== row.content &&
                     (row.type === 'diff-add' || row.type === 'diff-context')) {
@@ -323,6 +305,33 @@ export function wrapDisplayRows(rows, contentWidth, wrapEnabled) {
     }
     return result;
 }
+/**
+ * Find hunk boundaries in a DisplayRow or WrappedDisplayRow array.
+ * Each hunk spans from a 'diff-hunk' row to the next 'diff-hunk', 'diff-header', 'spacer', or end.
+ */
+export function getHunkBoundaries(rows) {
+    const boundaries = [];
+    let currentStart = -1;
+    for (let i = 0; i < rows.length; i++) {
+        const type = rows[i].type;
+        if (type === 'diff-hunk') {
+            if (currentStart !== -1) {
+                boundaries.push({ startRow: currentStart, endRow: i });
+            }
+            currentStart = i;
+        }
+        else if (type === 'diff-header' || type === 'spacer') {
+            if (currentStart !== -1) {
+                boundaries.push({ startRow: currentStart, endRow: i });
+                currentStart = -1;
+            }
+        }
+    }
+    if (currentStart !== -1) {
+        boundaries.push({ startRow: currentStart, endRow: rows.length });
+    }
+    return boundaries;
+}
 /**
  * Calculate the total row count after wrapping.
  * More efficient than wrapDisplayRows().length when you only need the count.
@@ -349,3 +358,74 @@ export function getWrappedRowCount(rows, contentWidth, wrapEnabled) {
     }
     return count;
 }
+/**
+ * Parse the index-referenced line number from a hunk header.
+ * Staged diffs (HEAD→index): use +new (new-side = index lines).
+ * Unstaged diffs (index→working tree): use -old (old-side = index lines).
+ */
+function parseHunkSortKey(hunkContent, source) {
+    const m = hunkContent.match(/@@ -(\d+)(?:,\d+)? \+(\d+)/);
+    if (!m)
+        return 0;
+    return source === 'staged' ? parseInt(m[2], 10) : parseInt(m[1], 10);
+}
+/**
+ * Extract individual hunks from a DiffResult's lines.
+ * Returns file-level header lines separately.
+ */
+function extractHunks(diff, source) {
+    if (!diff || diff.lines.length === 0)
+        return { fileHeaders: [], hunks: [] };
+    const fileHeaders = [];
+    const hunks = [];
+    let currentHunk = null;
+    let hunkIdx = 0;
+    for (const line of diff.lines) {
+        if (line.type === 'header') {
+            if (currentHunk) {
+                hunks.push(currentHunk);
+                currentHunk = null;
+            }
+            fileHeaders.push(line);
+        }
+        else if (line.type === 'hunk') {
+            if (currentHunk)
+                hunks.push(currentHunk);
+            currentHunk = {
+                headerLine: line,
+                bodyLines: [],
+                sortKey: parseHunkSortKey(line.content, source),
+                source,
+                hunkIndex: hunkIdx++,
+            };
+        }
+        else if (currentHunk) {
+            currentHunk.bodyLines.push(line);
+        }
+    }
+    if (currentHunk)
+        hunks.push(currentHunk);
+    return { fileHeaders, hunks };
+}
+/**
+ * Build combined display rows from unstaged and staged diffs for the same file.
+ * Hunks are interleaved by file position (index line number) into a single
+ * unified view. Returns display rows and a mapping from combined hunk index
+ * to source (unstaged/staged) and original hunk index.
+ */
+export function buildCombinedDiffDisplayRows(unstaged, staged) {
+    const u = extractHunks(unstaged, 'unstaged');
+    const s = extractHunks(staged, 'staged');
+    const allHunks = [...u.hunks, ...s.hunks];
+    allHunks.sort((a, b) => a.sortKey - b.sortKey);
+    // Build a merged DiffLine array: file headers from whichever has them, then sorted hunks
+    const fileHeaders = u.fileHeaders.length > 0 ? u.fileHeaders : s.fileHeaders;
+    const mergedLines = [...fileHeaders];
+    const hunkMapping = [];
+    for (const hunk of allHunks) {
+        mergedLines.push(hunk.headerLine, ...hunk.bodyLines);
+        hunkMapping.push({ source: hunk.source, hunkIndex: hunk.hunkIndex });
+    }
+    const rows = buildDiffDisplayRows({ raw: '', lines: mergedLines });
+    return { rows, hunkMapping };
+}