diffstalker 0.1.7 → 0.2.1

package/dist/utils/displayRows.js

@@ -3,18 +3,26 @@
 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';
 /**
- * Get the text content from a diff line (strip leading +/-/space)
+ * Get the text content from a diff line (strip leading +/-/space and control chars)
  */
 function getLineContent(line) {
+    let content;
     if (line.type === 'addition' || line.type === 'deletion') {
-        return line.content.slice(1);
+        content = line.content.slice(1);
     }
-    if (line.type === 'context') {
+    else if (line.type === 'context') {
         // Context lines start with space
-        return line.content.startsWith(' ') ? line.content.slice(1) : line.content;
+        content = line.content.startsWith(' ') ? line.content.slice(1) : line.content;
     }
-    return line.content;
+    else {
+        content = line.content;
+    }
+    // Strip control characters that cause rendering artifacts
+    // and convert tabs to spaces for consistent width calculation
+    return content.replace(/[\x00-\x08\x0a-\x1f\x7f]/g, '').replace(/\t/g, '    ');
 }
 /**
  * Convert a DiffLine to a DisplayRow
@@ -45,14 +53,185 @@ function convertDiffLineToDisplayRow(line) {
             };
     }
 }
+/**
+ * Extract file path from a diff --git header line.
+ */
+function extractFilePathFromHeader(content) {
+    const match = content.match(/^diff --git a\/.+ b\/(.+)$/);
+    return match ? match[1] : null;
+}
 /**
  * Build display rows from a DiffResult.
  * Filters out non-displayable lines (index, ---, +++ headers).
+ * Pairs consecutive deletions/additions within hunks and computes word-level diffs.
+ * Applies block-based syntax highlighting to properly handle multi-line constructs.
  */
 export function buildDiffDisplayRows(diff) {
     if (!diff)
         return [];
-    return diff.lines.filter(isDisplayableDiffLine).map(convertDiffLineToDisplayRow);
+    const filteredLines = diff.lines.filter(isDisplayableDiffLine);
+    const rows = [];
+    const fileSections = [];
+    let currentSection = null;
+    // Phase 1: Build display rows WITHOUT highlighting
+    // Also collect content for block highlighting
+    let i = 0;
+    while (i < filteredLines.length) {
+        const line = filteredLines[i];
+        // Headers - start new file section
+        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,
+                    oldContent: [],
+                    oldRowIndices: [],
+                    newContent: [],
+                    newRowIndices: [],
+                };
+            }
+            rows.push(convertDiffLineToDisplayRow(line));
+            i++;
+            continue;
+        }
+        // Hunks - just convert (don't highlight)
+        if (line.type === 'hunk') {
+            rows.push(convertDiffLineToDisplayRow(line));
+            i++;
+            continue;
+        }
+        // Context lines - add to both streams
+        if (line.type === 'context') {
+            const content = getLineContent(line);
+            const rowIndex = rows.length;
+            rows.push({
+                type: 'diff-context',
+                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);
+                currentSection.newContent.push(content);
+                currentSection.newRowIndices.push(rowIndex);
+            }
+            i++;
+            continue;
+        }
+        // Collect consecutive deletions
+        const deletions = [];
+        while (i < filteredLines.length && filteredLines[i].type === 'deletion') {
+            deletions.push(filteredLines[i]);
+            i++;
+        }
+        // Collect consecutive additions (immediately following deletions)
+        const additions = [];
+        while (i < filteredLines.length && filteredLines[i].type === 'addition') {
+            additions.push(filteredLines[i]);
+            i++;
+        }
+        // Build arrays to store word diff segments for paired lines
+        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);
+            const segments = delSegmentsMap.get(j);
+            const rowIndex = rows.length;
+            rows.push({
+                type: 'diff-del',
+                lineNum: delLine.oldLineNum,
+                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);
+            const segments = addSegmentsMap.get(j);
+            const rowIndex = rows.length;
+            rows.push({
+                type: 'diff-add',
+                lineNum: addLine.newLineNum,
+                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);
+    }
+    // Phase 2: Apply block highlighting for each file section
+    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')) {
+                    row.highlighted = highlighted;
+                }
+            }
+        }
+        // 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')) {
+                    row.highlighted = highlighted;
+                }
+            }
+        }
+    }
+    return rows;
 }
 /**
  * Build display rows from commit + diff (for History tab).

package/dist/utils/explorerDisplayRows.js

@@ -17,8 +17,8 @@ import { getLanguageFromPath, highlightLine } from './languageDetection.js';
 export function buildExplorerContentRows(content, filePath, truncated) {
     if (!content)
         return [];
-    const rows = [];
     const lines = content.split('\n');
+    const rows = [];
     // Detect language for highlighting
     const language = filePath ? getLanguageFromPath(filePath) : null;
     for (let i = 0; i < lines.length; i++) {

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/languageDetection.js

@@ -155,6 +155,7 @@ export function getLanguageFromPath(filePath) {
  * Apply syntax highlighting to a line of code.
  * Returns the highlighted string with ANSI escape codes.
  * If highlighting fails, returns the original content.
+ * Skips highlighting for lines that look like comments (heuristic for multi-line context).
  */
 export function highlightLine(content, language) {
     if (!content || !language)
@@ -168,6 +169,61 @@ export function highlightLine(content, language) {
         return content;
     }
 }
+/**
+ * Apply syntax highlighting preserving background color.
+ * Replaces full ANSI resets with foreground-only resets so that
+ * the caller's background color is not cleared.
+ * Returns the highlighted string, or original content if highlighting fails.
+ */
+export function highlightLinePreserveBg(content, language) {
+    if (!content || !language)
+        return content;
+    try {
+        const result = emphasize.highlight(language, content);
+        // Replace full reset (\x1b[0m) with foreground-only reset (\x1b[39m)
+        // This preserves any background color set by the caller
+        return result.value.replace(/\x1b\[0m/g, '\x1b[39m');
+    }
+    catch {
+        return content;
+    }
+}
+/**
+ * Highlight multiple lines as a block, preserving multi-line context
+ * (e.g., block comments, multi-line strings).
+ * Returns an array of highlighted lines.
+ */
+export function highlightBlock(lines, language) {
+    if (!language || lines.length === 0)
+        return lines;
+    try {
+        // Join lines and highlight as one block to preserve state
+        const block = lines.join('\n');
+        const result = emphasize.highlight(language, block);
+        return result.value.split('\n');
+    }
+    catch {
+        return lines;
+    }
+}
+/**
+ * Highlight multiple lines as a block, preserving background color.
+ * Returns an array of highlighted lines with foreground-only resets.
+ */
+export function highlightBlockPreserveBg(lines, language) {
+    if (!language || lines.length === 0)
+        return lines;
+    try {
+        const block = lines.join('\n');
+        const result = emphasize.highlight(language, block);
+        // Replace full resets with foreground-only resets
+        const highlighted = result.value.replace(/\x1b\[0m/g, '\x1b[39m');
+        return highlighted.split('\n');
+    }
+    catch {
+        return lines;
+    }
+}
 /**
  * Apply syntax highlighting to multiple lines.
  * More efficient than calling highlightLine for each line

package/dist/utils/pathUtils.js

@@ -0,0 +1,27 @@
+import * as path from 'node:path';
+import * as os from 'node:os';
+/**
+ * Expand tilde (~) to home directory.
+ */
+export function expandPath(p) {
+    if (p.startsWith('~/')) {
+        return path.join(os.homedir(), p.slice(2));
+    }
+    if (p === '~') {
+        return os.homedir();
+    }
+    return p;
+}
+/**
+ * Get the last non-empty line from content.
+ * Supports append-only files by reading only the last non-empty line.
+ */
+export function getLastNonEmptyLine(content) {
+    const lines = content.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (line)
+            return line;
+    }
+    return '';
+}

package/dist/utils/wordDiff.js

@@ -0,0 +1,50 @@
+// Word-level diff utility using fast-diff
+import fastDiff from 'fast-diff';
+/**
+ * Check if two lines are similar enough to warrant word-level diffing.
+ * Returns true if they share at least 30% common content.
+ */
+export function areSimilarEnough(oldText, newText) {
+    if (!oldText || !newText)
+        return false;
+    const diffs = fastDiff(oldText, newText);
+    let commonLength = 0;
+    let totalLength = 0;
+    for (const [type, text] of diffs) {
+        totalLength += text.length;
+        if (type === fastDiff.EQUAL) {
+            commonLength += text.length;
+        }
+    }
+    if (totalLength === 0)
+        return false;
+    // Require at least 50% similarity for word-level highlighting to be useful
+    const similarity = commonLength / totalLength;
+    return similarity >= 0.5;
+}
+/**
+ * Compute word-level diff between two strings.
+ * Returns segments for both the old (deleted) and new (added) lines,
+ * marking which portions changed.
+ */
+export function computeWordDiff(oldText, newText) {
+    const diffs = fastDiff(oldText, newText);
+    const oldSegments = [];
+    const newSegments = [];
+    for (const [type, text] of diffs) {
+        if (type === fastDiff.EQUAL) {
+            // Same in both - add to both segment lists
+            oldSegments.push({ text, type: 'same' });
+            newSegments.push({ text, type: 'same' });
+        }
+        else if (type === fastDiff.DELETE) {
+            // Deleted from old - only in old segments
+            oldSegments.push({ text, type: 'changed' });
+        }
+        else if (type === fastDiff.INSERT) {
+            // Inserted in new - only in new segments
+            newSegments.push({ text, type: 'changed' });
+        }
+    }
+    return { oldSegments, newSegments };
+}

package/eslint.metrics.js

@@ -0,0 +1,16 @@
+// 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-depth': ['warn', { max: 1 }],
+      'max-lines-per-function': ['warn', { max: 1 }],
+    },
+  },
+];