diffstalker 0.1.6 → 0.2.0

package/dist/ui/widgets/DiffView.js

@@ -0,0 +1,279 @@
+import { getTheme } from '../../themes.js';
+import { buildDiffDisplayRows, buildHistoryDisplayRows, getDisplayRowsLineNumWidth, wrapDisplayRows, } from '../../utils/displayRows.js';
+import { ansiToBlessed } from '../../utils/ansiToBlessed.js';
+import { truncateAnsi } from '../../utils/ansiTruncate.js';
+/**
+ * Truncate string to fit within maxWidth, adding ellipsis if needed.
+ */
+function truncate(str, maxWidth) {
+    if (maxWidth <= 0 || str.length <= maxWidth)
+        return str;
+    if (maxWidth <= 1)
+        return '\u2026';
+    return str.slice(0, maxWidth - 1) + '\u2026';
+}
+/**
+ * Format line number with padding.
+ */
+function formatLineNum(lineNum, width) {
+    if (lineNum === undefined)
+        return ' '.repeat(width);
+    return String(lineNum).padStart(width, ' ');
+}
+/**
+ * Escape blessed tags in content.
+ */
+function escapeContent(content) {
+    return content.replace(/\{/g, '{{').replace(/\}/g, '}}');
+}
+/**
+ * Build raw ANSI escape sequence for 24-bit RGB background.
+ */
+function ansiBg(hex) {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return `\x1b[48;2;${r};${g};${b}m`;
+}
+/**
+ * Build raw ANSI escape sequence for 24-bit RGB foreground.
+ */
+function ansiFg(hex) {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+const ANSI_RESET = '\x1b[0m';
+/**
+ * Format a single display row as blessed-compatible tagged string.
+ */
+function formatDisplayRow(row, lineNumWidth, contentWidth, headerWidth, theme, wrapMode) {
+    const { colors } = theme;
+    switch (row.type) {
+        case 'diff-header': {
+            const content = row.content;
+            if (content.startsWith('diff --git')) {
+                const match = content.match(/diff --git a\/.+ b\/(.+)$/);
+                if (match) {
+                    const maxPathLen = headerWidth - 6;
+                    const path = truncate(match[1], maxPathLen);
+                    return `{bold}{cyan-fg}\u2500\u2500 ${path} \u2500\u2500{/cyan-fg}{/bold}`;
+                }
+            }
+            return `{gray-fg}${escapeContent(truncate(content, headerWidth))}{/gray-fg}`;
+        }
+        case 'diff-hunk': {
+            const match = row.content.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/);
+            if (match) {
+                const oldStart = parseInt(match[1], 10);
+                const oldCount = match[2] ? parseInt(match[2], 10) : 1;
+                const newStart = parseInt(match[3], 10);
+                const newCount = match[4] ? parseInt(match[4], 10) : 1;
+                const context = match[5].trim();
+                const oldEnd = oldStart + oldCount - 1;
+                const newEnd = newStart + newCount - 1;
+                const oldRange = oldCount === 1 ? `${oldStart}` : `${oldStart}-${oldEnd}`;
+                const newRange = newCount === 1 ? `${newStart}` : `${newStart}-${newEnd}`;
+                const rangeText = `Lines ${oldRange} \u2192 ${newRange}`;
+                const contextMaxLen = headerWidth - rangeText.length - 1;
+                const truncatedContext = context && contextMaxLen > 3 ? ' ' + truncate(context, contextMaxLen) : '';
+                return `{cyan-fg}${rangeText}{/cyan-fg}{gray-fg}${truncatedContext}{/gray-fg}`;
+            }
+            return `{cyan-fg}${escapeContent(truncate(row.content, headerWidth))}{/cyan-fg}`;
+        }
+        case 'diff-add': {
+            const isCont = row.isContinuation;
+            const symbol = isCont ? '\u00bb' : '+';
+            const lineNum = formatLineNum(row.lineNum, lineNumWidth);
+            const prefix = `${lineNum} ${symbol}  `;
+            if (theme.name.includes('ansi')) {
+                // Basic ANSI theme - use blessed tags with 16-color palette
+                const rawContent = wrapMode ? row.content || '' : truncate(row.content || '', contentWidth);
+                const visibleContent = `${prefix}${rawContent}`;
+                const paddedContent = visibleContent.padEnd(headerWidth, ' ');
+                return `{green-bg}{white-fg}${escapeContent(paddedContent)}{/white-fg}{/green-bg}`;
+            }
+            // Use 24-bit RGB via {escape} tag
+            const bg = ansiBg(colors.addBg);
+            const highlightBg = ansiBg(colors.addHighlight);
+            const fg = ansiFg('#ffffff');
+            // Check for word-level diff segments (only in non-wrap mode or first row)
+            if (row.wordDiffSegments && !isCont) {
+                const rawContent = row.content || '';
+                // Check visible content length (not including escape codes)
+                if (!wrapMode && rawContent.length > contentWidth) {
+                    // Content too long - fall back to simple truncation without word highlighting
+                    const truncated = truncate(rawContent, contentWidth);
+                    const visibleContent = `${prefix}${truncated}`;
+                    const paddedContent = visibleContent.padEnd(headerWidth, ' ');
+                    return `{escape}${bg}${fg}${paddedContent}${ANSI_RESET}{/escape}`;
+                }
+                // Build content with word-level highlighting
+                let contentStr = '';
+                for (const seg of row.wordDiffSegments) {
+                    if (seg.type === 'changed') {
+                        contentStr += `${highlightBg}${seg.text}${bg}`;
+                    }
+                    else {
+                        contentStr += seg.text;
+                    }
+                }
+                // Calculate padding based on visible width (prefix + rawContent)
+                const visibleWidth = prefix.length + rawContent.length;
+                const padding = ' '.repeat(Math.max(0, headerWidth - visibleWidth));
+                return `{escape}${bg}${fg}${prefix}${contentStr}${padding}${ANSI_RESET}{/escape}`;
+            }
+            // Check for syntax highlighting (when no word-diff)
+            if (row.highlighted && !isCont) {
+                const rawContent = row.content || '';
+                if (!wrapMode && rawContent.length > contentWidth) {
+                    // Too long - fall back to plain truncation
+                    const truncated = truncate(rawContent, contentWidth);
+                    const visibleContent = `${prefix}${truncated}`;
+                    const paddedContent = visibleContent.padEnd(headerWidth, ' ');
+                    return `{escape}${bg}${fg}${paddedContent}${ANSI_RESET}{/escape}`;
+                }
+                // Use highlighted content (already has foreground colors, bg preserved)
+                const visibleWidth = prefix.length + rawContent.length;
+                const padding = ' '.repeat(Math.max(0, headerWidth - visibleWidth));
+                return `{escape}${bg}${fg}${prefix}${row.highlighted}${padding}${ANSI_RESET}{/escape}`;
+            }
+            const rawContent = wrapMode ? row.content || '' : truncate(row.content || '', contentWidth);
+            const visibleContent = `${prefix}${rawContent}`;
+            const paddedContent = visibleContent.padEnd(headerWidth, ' ');
+            return `{escape}${bg}${fg}${paddedContent}${ANSI_RESET}{/escape}`;
+        }
+        case 'diff-del': {
+            const isCont = row.isContinuation;
+            const symbol = isCont ? '\u00bb' : '-';
+            const lineNum = formatLineNum(row.lineNum, lineNumWidth);
+            const prefix = `${lineNum} ${symbol}  `;
+            if (theme.name.includes('ansi')) {
+                // Basic ANSI theme - use blessed tags with 16-color palette
+                const rawContent = wrapMode ? row.content || '' : truncate(row.content || '', contentWidth);
+                const visibleContent = `${prefix}${rawContent}`;
+                const paddedContent = visibleContent.padEnd(headerWidth, ' ');
+                return `{red-bg}{white-fg}${escapeContent(paddedContent)}{/white-fg}{/red-bg}`;
+            }
+            // Use 24-bit RGB via {escape} tag
+            const bg = ansiBg(colors.delBg);
+            const highlightBg = ansiBg(colors.delHighlight);
+            const fg = ansiFg('#ffffff');
+            // Check for word-level diff segments (only in non-wrap mode or first row)
+            if (row.wordDiffSegments && !isCont) {
+                const rawContent = row.content || '';
+                // Check visible content length (not including escape codes)
+                if (!wrapMode && rawContent.length > contentWidth) {
+                    // Content too long - fall back to simple truncation without word highlighting
+                    const truncated = truncate(rawContent, contentWidth);
+                    const visibleContent = `${prefix}${truncated}`;
+                    const paddedContent = visibleContent.padEnd(headerWidth, ' ');
+                    return `{escape}${bg}${fg}${paddedContent}${ANSI_RESET}{/escape}`;
+                }
+                // Build content with word-level highlighting
+                let contentStr = '';
+                for (const seg of row.wordDiffSegments) {
+                    if (seg.type === 'changed') {
+                        contentStr += `${highlightBg}${seg.text}${bg}`;
+                    }
+                    else {
+                        contentStr += seg.text;
+                    }
+                }
+                // Calculate padding based on visible width (prefix + rawContent)
+                const visibleWidth = prefix.length + rawContent.length;
+                const padding = ' '.repeat(Math.max(0, headerWidth - visibleWidth));
+                return `{escape}${bg}${fg}${prefix}${contentStr}${padding}${ANSI_RESET}{/escape}`;
+            }
+            // Check for syntax highlighting (when no word-diff)
+            if (row.highlighted && !isCont) {
+                const rawContent = row.content || '';
+                if (!wrapMode && rawContent.length > contentWidth) {
+                    // Too long - fall back to plain truncation
+                    const truncated = truncate(rawContent, contentWidth);
+                    const visibleContent = `${prefix}${truncated}`;
+                    const paddedContent = visibleContent.padEnd(headerWidth, ' ');
+                    return `{escape}${bg}${fg}${paddedContent}${ANSI_RESET}{/escape}`;
+                }
+                // Use highlighted content (already has foreground colors, bg preserved)
+                const visibleWidth = prefix.length + rawContent.length;
+                const padding = ' '.repeat(Math.max(0, headerWidth - visibleWidth));
+                return `{escape}${bg}${fg}${prefix}${row.highlighted}${padding}${ANSI_RESET}{/escape}`;
+            }
+            const rawContent = wrapMode ? row.content || '' : truncate(row.content || '', contentWidth);
+            const visibleContent = `${prefix}${rawContent}`;
+            const paddedContent = visibleContent.padEnd(headerWidth, ' ');
+            return `{escape}${bg}${fg}${paddedContent}${ANSI_RESET}{/escape}`;
+        }
+        case 'diff-context': {
+            const isCont = row.isContinuation;
+            const symbol = isCont ? '\u00bb' : ' ';
+            const lineNum = formatLineNum(row.lineNum, lineNumWidth);
+            const prefix = `${lineNum} ${symbol}  `;
+            const rawContent = row.content || '';
+            // Use syntax highlighting if available (not for continuations)
+            if (row.highlighted && !isCont) {
+                const truncatedHighlight = wrapMode
+                    ? row.highlighted
+                    : truncateAnsi(row.highlighted, contentWidth);
+                const highlightedContent = ansiToBlessed(truncatedHighlight);
+                return `{gray-fg}${prefix}{/gray-fg}${highlightedContent}`;
+            }
+            const content = wrapMode
+                ? escapeContent(rawContent)
+                : escapeContent(truncate(rawContent, contentWidth));
+            return `{gray-fg}${prefix}{/gray-fg}${content}`;
+        }
+        case 'commit-header':
+            return `{yellow-fg}${escapeContent(truncate(row.content, headerWidth))}{/yellow-fg}`;
+        case 'commit-message':
+            return escapeContent(truncate(row.content, headerWidth));
+        case 'spacer':
+            return '';
+    }
+}
+/**
+ * Format diff output as blessed-compatible tagged string.
+ * Returns both the content and total row count for scroll calculations.
+ */
+export function formatDiff(diff, width, scrollOffset = 0, maxHeight, themeName = 'dark', wrapMode = false) {
+    const displayRows = buildDiffDisplayRows(diff);
+    if (displayRows.length === 0) {
+        return { content: '{gray-fg}No diff to display{/gray-fg}', totalRows: 0 };
+    }
+    const theme = getTheme(themeName);
+    const lineNumWidth = getDisplayRowsLineNumWidth(displayRows);
+    const contentWidth = width - lineNumWidth - 5; // line num + space + symbol + space + padding
+    const headerWidth = width - 2;
+    // Apply wrapping if enabled
+    const wrappedRows = wrapDisplayRows(displayRows, contentWidth, wrapMode);
+    const totalRows = wrappedRows.length;
+    // Apply scroll offset and max height
+    const visibleRows = maxHeight
+        ? wrappedRows.slice(scrollOffset, scrollOffset + maxHeight)
+        : wrappedRows.slice(scrollOffset);
+    const lines = visibleRows.map((row) => formatDisplayRow(row, lineNumWidth, contentWidth, headerWidth, theme, wrapMode));
+    return { content: lines.join('\n'), totalRows };
+}
+/**
+ * Format history diff (commit metadata + diff) as blessed-compatible tagged string.
+ * Returns both the content and total row count for scroll calculations.
+ */
+export function formatHistoryDiff(commit, diff, width, scrollOffset = 0, maxHeight, themeName = 'dark', wrapMode = false) {
+    const displayRows = buildHistoryDisplayRows(commit, diff);
+    if (displayRows.length === 0) {
+        return { content: '{gray-fg}No commit selected{/gray-fg}', totalRows: 0 };
+    }
+    const theme = getTheme(themeName);
+    const lineNumWidth = getDisplayRowsLineNumWidth(displayRows);
+    const contentWidth = width - lineNumWidth - 5;
+    const headerWidth = width - 2;
+    const wrappedRows = wrapDisplayRows(displayRows, contentWidth, wrapMode);
+    const totalRows = wrappedRows.length;
+    const visibleRows = maxHeight
+        ? wrappedRows.slice(scrollOffset, scrollOffset + maxHeight)
+        : wrappedRows.slice(scrollOffset);
+    const lines = visibleRows.map((row) => formatDisplayRow(row, lineNumWidth, contentWidth, headerWidth, theme, wrapMode));
+    return { content: lines.join('\n'), totalRows };
+}

package/dist/ui/widgets/ExplorerContent.js

@@ -0,0 +1,102 @@
+import { buildExplorerContentRows, wrapExplorerContentRows, getExplorerContentRowCount, getExplorerContentLineNumWidth, applyMiddleDots, } from '../../utils/explorerDisplayRows.js';
+import { truncateAnsi } from '../../utils/ansiTruncate.js';
+import { ansiToBlessed } from '../../utils/ansiToBlessed.js';
+/**
+ * Escape blessed tags in content.
+ */
+function escapeContent(content) {
+    return content.replace(/\{/g, '{{').replace(/\}/g, '}}');
+}
+/**
+ * Format explorer file content as blessed-compatible tagged string.
+ */
+export function formatExplorerContent(filePath, content, width, scrollOffset = 0, maxHeight, truncated = false, wrapMode = false, showMiddleDots = false) {
+    if (!filePath) {
+        return '{gray-fg}Select a file to view its contents{/gray-fg}';
+    }
+    if (!content) {
+        return '{gray-fg}Loading...{/gray-fg}';
+    }
+    // Build base rows with syntax highlighting
+    const baseRows = buildExplorerContentRows(content, filePath, truncated);
+    if (baseRows.length === 0) {
+        return '{gray-fg}(empty file){/gray-fg}';
+    }
+    // Calculate line number width
+    const lineNumWidth = getExplorerContentLineNumWidth(baseRows);
+    // Calculate content width for wrapping
+    // Layout: lineNum + space(1) + content
+    const contentWidth = width - lineNumWidth - 2;
+    // Apply wrapping if enabled
+    const displayRows = wrapExplorerContentRows(baseRows, contentWidth, wrapMode);
+    // Apply scroll offset and max height
+    const visibleRows = maxHeight
+        ? displayRows.slice(scrollOffset, scrollOffset + maxHeight)
+        : displayRows.slice(scrollOffset);
+    const lines = [];
+    for (const row of visibleRows) {
+        if (row.type === 'truncation') {
+            lines.push(`{yellow-fg}${escapeContent(row.content)}{/yellow-fg}`);
+            continue;
+        }
+        // Code row
+        const isContinuation = row.isContinuation ?? false;
+        // Line number display
+        let lineNumDisplay;
+        if (isContinuation) {
+            lineNumDisplay = '>>'.padStart(lineNumWidth, ' ');
+        }
+        else {
+            lineNumDisplay = String(row.lineNum).padStart(lineNumWidth, ' ');
+        }
+        // Determine what content to display
+        const rawContent = row.content;
+        const shouldTruncate = !wrapMode && rawContent.length > contentWidth;
+        // Use highlighted content if available and not a continuation or middle-dots mode
+        const canUseHighlighting = row.highlighted && !isContinuation && !showMiddleDots;
+        let displayContent;
+        if (canUseHighlighting && row.highlighted) {
+            // Use ANSI-aware truncation to preserve syntax highlighting
+            const truncatedHighlight = shouldTruncate
+                ? truncateAnsi(row.highlighted, contentWidth)
+                : row.highlighted;
+            // Convert ANSI to blessed tags
+            displayContent = ansiToBlessed(truncatedHighlight);
+        }
+        else {
+            // Plain content path
+            let plainContent = rawContent;
+            // Apply middle-dots to raw content
+            if (showMiddleDots && !isContinuation) {
+                plainContent = applyMiddleDots(plainContent, true);
+            }
+            // Simple truncation for plain content
+            if (shouldTruncate) {
+                plainContent = plainContent.slice(0, Math.max(0, contentWidth - 1)) + '...';
+            }
+            displayContent = escapeContent(plainContent);
+        }
+        // Format line with line number
+        let line = '';
+        if (isContinuation) {
+            line = `{cyan-fg}${lineNumDisplay}{/cyan-fg} ${displayContent || ' '}`;
+        }
+        else {
+            line = `{gray-fg}${lineNumDisplay}{/gray-fg} ${displayContent || ' '}`;
+        }
+        lines.push(line);
+    }
+    return lines.join('\n');
+}
+/**
+ * Get total rows for scroll calculations.
+ * Accounts for wrap mode when calculating.
+ */
+export function getExplorerContentTotalRows(content, filePath, truncated, width, wrapMode) {
+    if (!content)
+        return 0;
+    const rows = buildExplorerContentRows(content, filePath, truncated);
+    const lineNumWidth = getExplorerContentLineNumWidth(rows);
+    const contentWidth = width - lineNumWidth - 2;
+    return getExplorerContentRowCount(rows, contentWidth, wrapMode);
+}

package/dist/ui/widgets/ExplorerView.js

@@ -0,0 +1,95 @@
+/**
+ * Escape blessed tags in content.
+ */
+function escapeContent(content) {
+    return content.replace(/\{/g, '{{').replace(/\}/g, '}}');
+}
+/**
+ * Format the explorer directory listing as blessed-compatible tagged string.
+ */
+export function formatExplorerView(items, selectedIndex, isFocused, width, scrollOffset = 0, maxHeight, isLoading = false, error = null) {
+    if (error) {
+        return `{red-fg}Error: ${escapeContent(error)}{/red-fg}`;
+    }
+    if (isLoading) {
+        return '{gray-fg}Loading...{/gray-fg}';
+    }
+    if (items.length === 0) {
+        return '{gray-fg}(empty directory){/gray-fg}';
+    }
+    // Apply scroll offset and max height
+    const visibleItems = maxHeight
+        ? items.slice(scrollOffset, scrollOffset + maxHeight)
+        : items.slice(scrollOffset);
+    // Calculate max name width for alignment
+    const maxNameWidth = Math.min(Math.max(...items.map((item) => item.name.length + (item.isDirectory ? 1 : 0))), width - 10);
+    const lines = [];
+    for (let i = 0; i < visibleItems.length; i++) {
+        const item = visibleItems[i];
+        const actualIndex = scrollOffset + i;
+        const isSelected = actualIndex === selectedIndex;
+        const isHighlighted = isSelected && isFocused;
+        const displayName = item.isDirectory ? `${item.name}/` : item.name;
+        const paddedName = displayName.padEnd(maxNameWidth + 1);
+        let line = '';
+        if (isHighlighted) {
+            // Selected and focused - highlight with cyan
+            if (item.isDirectory) {
+                line = `{cyan-fg}{bold}{inverse}${escapeContent(paddedName)}{/inverse}{/bold}{/cyan-fg}`;
+            }
+            else {
+                line = `{cyan-fg}{bold}{inverse}${escapeContent(paddedName)}{/inverse}{/bold}{/cyan-fg}`;
+            }
+        }
+        else {
+            // Not selected or not focused
+            if (item.isDirectory) {
+                line = `{blue-fg}${escapeContent(paddedName)}{/blue-fg}`;
+            }
+            else {
+                line = escapeContent(paddedName);
+            }
+        }
+        lines.push(line);
+    }
+    return lines.join('\n');
+}
+/**
+ * Build breadcrumb segments from a path.
+ * Returns segments like ["src", "components"] for "src/components"
+ */
+export function buildBreadcrumbs(currentPath) {
+    if (!currentPath)
+        return [];
+    return currentPath.split('/').filter(Boolean);
+}
+/**
+ * Format breadcrumbs for display.
+ */
+export function formatBreadcrumbs(currentPath, repoName) {
+    const segments = buildBreadcrumbs(currentPath);
+    if (segments.length === 0) {
+        return `{bold}${escapeContent(repoName)}{/bold}`;
+    }
+    const parts = [repoName, ...segments];
+    return parts
+        .map((part, i) => {
+        if (i === parts.length - 1) {
+            return `{bold}${escapeContent(part)}{/bold}`;
+        }
+        return `{gray-fg}${escapeContent(part)}{/gray-fg}`;
+    })
+        .join('{gray-fg}/{/gray-fg}');
+}
+/**
+ * Get total rows in explorer for scroll calculations.
+ */
+export function getExplorerTotalRows(items) {
+    return items.length;
+}
+/**
+ * Get item at index.
+ */
+export function getExplorerItemAtIndex(items, index) {
+    return items[index] ?? null;
+}

package/dist/ui/widgets/FileList.js

@@ -0,0 +1,185 @@
+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(' ') : '';
+}
+/**
+ * Build the list of row items for the file list.
+ */
+export function buildFileListRows(files) {
+    const { modified, untracked, staged } = categorizeFiles(files);
+    const rows = [];
+    let currentFileIndex = 0;
+    if (modified.length > 0) {
+        rows.push({ type: 'header', content: 'Modified:', headerColor: 'yellow' });
+        modified.forEach((file) => {
+            rows.push({ type: 'file', file, fileIndex: currentFileIndex++ });
+        });
+    }
+    if (untracked.length > 0) {
+        if (modified.length > 0) {
+            rows.push({ type: 'spacer' });
+        }
+        rows.push({ type: 'header', content: 'Untracked:', headerColor: 'gray' });
+        untracked.forEach((file) => {
+            rows.push({ type: 'file', file, fileIndex: currentFileIndex++ });
+        });
+    }
+    if (staged.length > 0) {
+        if (modified.length > 0 || untracked.length > 0) {
+            rows.push({ type: 'spacer' });
+        }
+        rows.push({ type: 'header', content: 'Staged:', headerColor: 'green' });
+        staged.forEach((file) => {
+            rows.push({ type: 'file', file, fileIndex: currentFileIndex++ });
+        });
+    }
+    return rows;
+}
+/**
+ * Format the file list as blessed-compatible tagged string.
+ */
+export function formatFileList(files, selectedIndex, isFocused, width, scrollOffset = 0, maxHeight) {
+    if (files.length === 0) {
+        return '{gray-fg} No changes{/gray-fg}';
+    }
+    const rows = buildFileListRows(files);
+    const maxPathLength = width - 12; // Account for prefix chars
+    // Apply scroll offset and max height
+    const visibleRows = maxHeight
+        ? rows.slice(scrollOffset, scrollOffset + maxHeight)
+        : rows.slice(scrollOffset);
+    const lines = [];
+    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}`;
+            }
+            // Stats
+            line += stats;
+            lines.push(line);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Get the total number of rows in the file list (for scroll calculation).
+ */
+export function getFileListTotalRows(files) {
+    return buildFileListRows(files).length;
+}
+/**
+ * Get the file at a specific index (accounting for category ordering).
+ */
+export function getFileAtIndex(files, index) {
+    const { ordered } = categorizeFiles(files);
+    return ordered[index] ?? null;
+}
+/**
+ * Get the file index from a visual row (accounting for headers and spacers).
+ * Returns null if the row is a header or spacer.
+ */
+export function getFileIndexFromRow(row, files) {
+    const rows = buildFileListRows(files);
+    const rowItem = rows[row];
+    if (rowItem?.type === 'file' && rowItem.fileIndex !== undefined) {
+        return rowItem.fileIndex;
+    }
+    return null;
+}
+/**
+ * Get the visual row index for a file index.
+ */
+export function getRowFromFileIndex(fileIndex, files) {
+    const rows = buildFileListRows(files);
+    for (let i = 0; i < rows.length; i++) {
+        if (rows[i].type === 'file' && rows[i].fileIndex === fileIndex) {
+            return i;
+        }
+    }
+    return 0;
+}