diffstalker 0.2.1 → 0.2.3

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,10 +22,23 @@ 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.
  */
-export function formatHeader(repoPath, branch, isLoading, error, width) {
+export function formatHeader(repoPath, branch, isLoading, error, width, remoteState) {
     if (!repoPath) {
         return '{gray-fg}Waiting for target path...{/gray-fg}';
     }
@@ -42,6 +55,39 @@ export function formatHeader(repoPath, branch, isLoading, error, width) {
     else if (error) {
         leftContent += ` {red-fg}(${error}){/red-fg}`;
     }
+    // Remote operation status (shown after left content)
+    let remoteStatus = '';
+    let remoteStatusLen = 0;
+    if (remoteState) {
+        if (remoteState.inProgress && remoteState.operation) {
+            const labels = {
+                push: 'pushing...',
+                fetch: 'fetching...',
+                pull: 'rebasing...',
+                stash: 'stashing...',
+                stashPop: 'popping stash...',
+                branchSwitch: 'switching branch...',
+                branchCreate: 'creating branch...',
+                softReset: 'resetting...',
+                cherryPick: 'cherry-picking...',
+                revert: 'reverting...',
+            };
+            const label = labels[remoteState.operation] ?? '';
+            remoteStatus = ` {yellow-fg}${label}{/yellow-fg}`;
+            remoteStatusLen = 1 + label.length;
+        }
+        else if (remoteState.error) {
+            const brief = remoteState.error.length > 40
+                ? remoteState.error.slice(0, 40) + '\u2026'
+                : remoteState.error;
+            remoteStatus = ` {red-fg}${brief}{/red-fg}`;
+            remoteStatusLen = 1 + brief.length;
+        }
+        else if (remoteState.lastResult) {
+            remoteStatus = ` {green-fg}${remoteState.lastResult}{/green-fg}`;
+            remoteStatusLen = 1 + remoteState.lastResult.length;
+        }
+    }
     // Build right side content (branch info)
     const rightContent = branch ? formatBranch(branch) : '';
     if (rightContent) {
@@ -55,14 +101,10 @@ 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;
+        leftLen += remoteStatusLen;
+        const rightLen = branch ? computeBranchVisibleLength(branch) : 0;
         const padding = Math.max(1, width - leftLen - rightLen - 2);
-        return leftContent + ' '.repeat(padding) + rightContent;
+        return leftContent + remoteStatus + ' '.repeat(padding) + rightContent;
     }
-    return leftContent;
+    return leftContent + remoteStatus;
 }

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