diffstalker 0.2.0 → 0.2.2

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 };
+}

package/dist/utils/fileCategories.js

@@ -24,3 +24,40 @@ export function getFileListSectionCounts(files) {
         stagedCount: staged.length,
     };
 }
+/**
+ * Which category does flat index `i` fall in, and what's the position within it?
+ * Flat order is: modified → untracked → staged.
+ */
+export function getCategoryForIndex(files, index) {
+    const { modified, untracked } = categorizeFiles(files);
+    const modLen = modified.length;
+    const untLen = untracked.length;
+    if (index < modLen) {
+        return { category: 'modified', categoryIndex: index };
+    }
+    if (index < modLen + untLen) {
+        return { category: 'untracked', categoryIndex: index - modLen };
+    }
+    return { category: 'staged', categoryIndex: index - modLen - untLen };
+}
+/**
+ * Convert category + position back to a flat index (clamped).
+ * If the target category is empty, falls back to last file overall, or 0 if no files.
+ */
+export function getIndexForCategoryPosition(files, category, categoryIndex) {
+    const { modified, untracked, staged, ordered } = categorizeFiles(files);
+    if (ordered.length === 0)
+        return 0;
+    const categories = { modified, untracked, staged };
+    const catFiles = categories[category];
+    if (catFiles.length === 0) {
+        return ordered.length - 1;
+    }
+    const clampedIndex = Math.min(categoryIndex, catFiles.length - 1);
+    const offsets = {
+        modified: 0,
+        untracked: modified.length,
+        staged: modified.length + untracked.length,
+    };
+    return offsets[category] + clampedIndex;
+}

package/dist/utils/fileTree.js

@@ -0,0 +1,148 @@
+/**
+ * Utility for building a tree view from flat file paths.
+ * Collapses single-child directories into combined path segments.
+ */
+/**
+ * Build a tree structure from flat file paths.
+ * Paths should be sorted alphabetically before calling this.
+ */
+export function buildFileTree(files) {
+    // Root node
+    const root = {
+        name: '',
+        fullPath: '',
+        isDirectory: true,
+        children: [],
+        depth: 0,
+    };
+    // Build initial trie structure
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const parts = file.path.split('/');
+        let current = root;
+        for (let j = 0; j < parts.length; j++) {
+            const part = parts[j];
+            const isFile = j === parts.length - 1;
+            const pathSoFar = parts.slice(0, j + 1).join('/');
+            let child = current.children.find((c) => c.name === part && c.isDirectory === !isFile);
+            if (!child) {
+                child = {
+                    name: part,
+                    fullPath: pathSoFar,
+                    isDirectory: !isFile,
+                    children: [],
+                    depth: current.depth + 1,
+                    fileIndex: isFile ? i : undefined,
+                };
+                current.children.push(child);
+            }
+            current = child;
+        }
+    }
+    // Collapse single-child directories
+    collapseTree(root);
+    // Sort children: directories first, then files, alphabetically
+    sortTree(root);
+    return root;
+}
+/**
+ * Collapse single-child directory chains.
+ * e.g., a -> b -> c -> file becomes "a/b/c" -> file
+ */
+function collapseTree(node) {
+    // First, recursively collapse children
+    for (const child of node.children) {
+        collapseTree(child);
+    }
+    // Then collapse this node's single-child directory chains
+    for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        // Collapse if: directory with exactly one child that is also a directory
+        while (child.isDirectory && child.children.length === 1 && child.children[0].isDirectory) {
+            const grandchild = child.children[0];
+            child.name = `${child.name}/${grandchild.name}`;
+            child.fullPath = grandchild.fullPath;
+            child.children = grandchild.children;
+            // Update depths of all descendants
+            updateDepths(child, child.depth);
+        }
+    }
+}
+/**
+ * Update depths recursively after collapsing.
+ */
+function updateDepths(node, depth) {
+    node.depth = depth;
+    for (const child of node.children) {
+        updateDepths(child, depth + 1);
+    }
+}
+/**
+ * Sort tree: directories first (alphabetically), then files (alphabetically).
+ */
+function sortTree(node) {
+    node.children.sort((a, b) => {
+        // Directories before files
+        if (a.isDirectory && !b.isDirectory)
+            return -1;
+        if (!a.isDirectory && b.isDirectory)
+            return 1;
+        // Alphabetically within same type
+        return a.name.localeCompare(b.name);
+    });
+    for (const child of node.children) {
+        sortTree(child);
+    }
+}
+/**
+ * Flatten tree into a list of row items for rendering.
+ * Skips the root node (which has empty name).
+ */
+export function flattenTree(root) {
+    const rows = [];
+    function traverse(node, parentIsLast) {
+        for (let i = 0; i < node.children.length; i++) {
+            const child = node.children[i];
+            const isLast = i === node.children.length - 1;
+            rows.push({
+                type: child.isDirectory ? 'directory' : 'file',
+                name: child.name,
+                fullPath: child.fullPath,
+                depth: child.depth - 1, // Subtract 1 because root is depth 0
+                fileIndex: child.fileIndex,
+                isLast,
+                parentIsLast: [...parentIsLast],
+            });
+            if (child.isDirectory) {
+                traverse(child, [...parentIsLast, isLast]);
+            }
+        }
+    }
+    traverse(root, []);
+    return rows;
+}
+/**
+ * Build tree prefix for rendering (the │ ├ └ characters).
+ */
+export function buildTreePrefix(row) {
+    let prefix = '';
+    // Add vertical lines for parent levels
+    for (let i = 0; i < row.depth; i++) {
+        if (row.parentIsLast[i]) {
+            prefix += '  '; // Parent was last, no line needed
+        }
+        else {
+            prefix += '│ '; // Parent has siblings below, draw line
+        }
+    }
+    // Add connector for this item
+    if (row.depth >= 0) {
+        if (row.isLast) {
+            prefix += '└ ';
+        }
+        else {
+            prefix += '├ ';
+        }
+    }
+    return prefix;
+}

package/dist/utils/flatFileList.js

@@ -0,0 +1,67 @@
+/**
+ * Build a deduplicated, alphabetically sorted flat file list.
+ * Files that appear in both staged and unstaged are merged into one entry
+ * with stagingState 'partial'.
+ */
+export function buildFlatFileList(files, hunkCounts) {
+    // Group by path
+    const byPath = new Map();
+    for (const file of files) {
+        const existing = byPath.get(file.path) ?? { staged: null, unstaged: null };
+        if (file.staged) {
+            existing.staged = file;
+        }
+        else {
+            existing.unstaged = file;
+        }
+        byPath.set(file.path, existing);
+    }
+    const result = [];
+    for (const [filePath, { staged, unstaged }] of byPath) {
+        const stagedHunks = hunkCounts?.staged.get(filePath) ?? 0;
+        const unstagedHunks = hunkCounts?.unstaged.get(filePath) ?? 0;
+        const totalHunks = stagedHunks + unstagedHunks;
+        let stagingState;
+        if (staged && unstaged) {
+            stagingState = 'partial';
+        }
+        else if (staged) {
+            stagingState = 'staged';
+        }
+        else {
+            stagingState = 'unstaged';
+        }
+        // Use the unstaged entry as primary (for status), fall back to staged
+        const primary = unstaged ?? staged;
+        // Combine insertions/deletions from both entries
+        let insertions;
+        let deletions;
+        if (staged?.insertions !== undefined || unstaged?.insertions !== undefined) {
+            insertions = (staged?.insertions ?? 0) + (unstaged?.insertions ?? 0);
+        }
+        if (staged?.deletions !== undefined || unstaged?.deletions !== undefined) {
+            deletions = (staged?.deletions ?? 0) + (unstaged?.deletions ?? 0);
+        }
+        result.push({
+            path: filePath,
+            status: primary.status,
+            stagingState,
+            stagedHunks,
+            totalHunks,
+            insertions,
+            deletions,
+            originalPath: primary.originalPath,
+            stagedEntry: staged,
+            unstagedEntry: unstaged,
+        });
+    }
+    // Sort alphabetically by path
+    result.sort((a, b) => a.path.localeCompare(b.path));
+    return result;
+}
+export function getFlatFileAtIndex(flatFiles, index) {
+    return flatFiles[index] ?? null;
+}
+export function getFlatFileIndexByPath(flatFiles, path) {
+    return flatFiles.findIndex((f) => f.path === path);
+}

package/dist/utils/layoutCalculations.js

@@ -32,11 +32,13 @@ export function getFileListTotalRows(files) {
  *
  * The top pane grows to fit files up to 40% of content height.
  * The bottom pane gets the remaining space.
+ *
+ * When flatRowCount is provided (flat view mode), uses that directly instead
+ * of computing row count from categorized file list.
  */
-export function calculatePaneHeights(files, contentHeight, maxTopRatio = 0.4) {
+export function calculatePaneHeights(files, contentHeight, maxTopRatio = 0.4, flatRowCount) {
     // Calculate content rows needed for staging area
-    // Uses getFileListTotalRows for consistency with FileList rendering
-    const neededRows = getFileListTotalRows(files);
+    const neededRows = flatRowCount !== undefined ? flatRowCount : getFileListTotalRows(files);
     // Minimum height of 3 (header + 2 lines for empty state)
     const minHeight = 3;
     // Maximum is maxTopRatio of content area

package/eslint.metrics.js

@@ -0,0 +1,15 @@
+// eslint.metrics.js
+// Used by the metrics script to gather complexity data.
+// Warns at low thresholds so all functions appear in the output.
+import baseConfig from './eslint.config.js';
+
+export default [
+  ...baseConfig,
+  {
+    rules: {
+      complexity: ['warn', { max: 1 }],
+      'sonarjs/cognitive-complexity': ['warn', 1],
+      'max-lines-per-function': ['warn', { max: 1 }],
+    },
+  },
+];