diffstalker 0.1.6 → 0.2.0

package/dist/ui/widgets/Footer.js

@@ -0,0 +1,46 @@
+/**
+ * Calculate visible length by stripping blessed tags.
+ */
+function calculateVisibleLength(content) {
+    return content.replace(/\{[^}]+\}/g, '').length;
+}
+/**
+ * Format footer content as blessed-compatible tagged string.
+ */
+export function formatFooter(activeTab, mouseEnabled, autoTabEnabled, wrapMode, showMiddleDots, width) {
+    // 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}';
+    if (activeTab === 'explorer') {
+        leftContent += ' ';
+        leftContent += showMiddleDots ? '{blue-fg}[dots]{/blue-fg}' : '{gray-fg}[dots]{/gray-fg}';
+    }
+    // Right side: tabs
+    const tabs = [
+        { key: '1', label: 'Diff', tab: 'diff' },
+        { key: '2', label: 'Commit', tab: 'commit' },
+        { key: '3', label: 'History', tab: 'history' },
+        { key: '4', label: 'Compare', tab: 'compare' },
+        { key: '5', label: 'Explorer', tab: 'explorer' },
+    ];
+    const rightContent = tabs
+        .map(({ key, label, tab }) => {
+        const isActive = activeTab === tab;
+        if (isActive) {
+            return `{bold}{cyan-fg}[${key}]${label}{/cyan-fg}{/bold}`;
+        }
+        return `[${key}]${label}`;
+    })
+        .join(' ');
+    // Calculate padding for right alignment
+    const leftLen = calculateVisibleLength(leftContent);
+    const rightLen = calculateVisibleLength(rightContent);
+    const padding = Math.max(1, width - leftLen - rightLen);
+    return leftContent + ' '.repeat(padding) + rightContent;
+}

package/dist/ui/widgets/Header.js

@@ -0,0 +1,111 @@
+import { abbreviateHomePath } from '../../config.js';
+/**
+ * Calculate header height based on content.
+ */
+export function getHeaderHeight(repoPath, branch, watcherState, width, error = null, isLoading = false) {
+    if (!repoPath)
+        return 1;
+    const displayPath = abbreviateHomePath(repoPath);
+    const isNotGitRepo = error === 'Not a git repository';
+    // Calculate branch width
+    let branchWidth = 0;
+    if (branch) {
+        branchWidth = branch.current.length;
+        if (branch.tracking)
+            branchWidth += 3 + branch.tracking.length;
+        if (branch.ahead > 0)
+            branchWidth += 3 + String(branch.ahead).length;
+        if (branch.behind > 0)
+            branchWidth += 3 + String(branch.behind).length;
+    }
+    // Calculate left side width
+    let leftWidth = displayPath.length;
+    if (isLoading)
+        leftWidth += 2;
+    if (isNotGitRepo)
+        leftWidth += 24;
+    if (error && !isNotGitRepo)
+        leftWidth += error.length + 3;
+    // Check if follow indicator causes wrap
+    if (watcherState?.enabled && watcherState.sourceFile) {
+        const followPath = abbreviateHomePath(watcherState.sourceFile);
+        const fullFollow = ` (follow: ${followPath})`;
+        const availableOneLine = width - leftWidth - branchWidth - 4;
+        if (fullFollow.length > availableOneLine) {
+            const availableWithWrap = width - leftWidth - 2;
+            if (fullFollow.length <= availableWithWrap) {
+                return 2;
+            }
+        }
+    }
+    return 1;
+}
+/**
+ * Format branch info as blessed-compatible tagged string.
+ */
+function formatBranch(branch) {
+    let result = `{bold}{green-fg}${branch.current}{/green-fg}{/bold}`;
+    if (branch.tracking) {
+        result += ` {gray-fg}\u2192{/gray-fg} {blue-fg}${branch.tracking}{/blue-fg}`;
+    }
+    if (branch.ahead > 0) {
+        result += ` {green-fg}\u2191${branch.ahead}{/green-fg}`;
+    }
+    if (branch.behind > 0) {
+        result += ` {red-fg}\u2193${branch.behind}{/red-fg}`;
+    }
+    return result;
+}
+/**
+ * Format header content as blessed-compatible tagged string.
+ */
+export function formatHeader(repoPath, branch, isLoading, error, watcherState, width) {
+    if (!repoPath) {
+        return '{gray-fg}Waiting for target path...{/gray-fg}';
+    }
+    const displayPath = abbreviateHomePath(repoPath);
+    const isNotGitRepo = error === 'Not a git repository';
+    // Build left side content
+    let leftContent = `{bold}{cyan-fg}${displayPath}{/cyan-fg}{/bold}`;
+    if (isLoading) {
+        leftContent += ' {yellow-fg}\u27f3{/yellow-fg}';
+    }
+    if (isNotGitRepo) {
+        leftContent += ' {yellow-fg}(not a git repository){/yellow-fg}';
+    }
+    else if (error) {
+        leftContent += ` {red-fg}(${error}){/red-fg}`;
+    }
+    // Add follow indicator if enabled
+    if (watcherState?.enabled && watcherState.sourceFile) {
+        const followPath = abbreviateHomePath(watcherState.sourceFile);
+        leftContent += ` {gray-fg}(follow: ${followPath}){/gray-fg}`;
+    }
+    // Build right side content (branch info)
+    const rightContent = branch ? formatBranch(branch) : '';
+    if (rightContent) {
+        // Calculate visible text length for left side (excluding ANSI/tags)
+        let leftLen = displayPath.length;
+        if (isLoading)
+            leftLen += 2; // " ⟳"
+        if (isNotGitRepo) {
+            leftLen += 24; // " (not a git repository)"
+        }
+        else if (error) {
+            leftLen += error.length + 3; // " (error)"
+        }
+        if (watcherState?.enabled && watcherState.sourceFile) {
+            const followPath = abbreviateHomePath(watcherState.sourceFile);
+            leftLen += 10 + followPath.length; // " (follow: path)"
+        }
+        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 padding = Math.max(1, width - leftLen - rightLen - 2);
+        return leftContent + ' '.repeat(padding) + rightContent;
+    }
+    return leftContent;
+}

package/dist/ui/widgets/HistoryView.js

@@ -0,0 +1,69 @@
+import { formatDate } from '../../utils/formatDate.js';
+import { formatCommitDisplay } from '../../utils/commitFormat.js';
+/**
+ * Format the history view as blessed-compatible tagged string.
+ */
+export function formatHistoryView(commits, selectedIndex, isFocused, width, scrollOffset = 0, maxHeight) {
+    if (commits.length === 0) {
+        return '{gray-fg}No commits yet{/gray-fg}';
+    }
+    // Apply scroll offset and max height
+    const visibleCommits = maxHeight
+        ? commits.slice(scrollOffset, scrollOffset + maxHeight)
+        : commits.slice(scrollOffset);
+    const lines = [];
+    for (let i = 0; i < visibleCommits.length; i++) {
+        const commit = visibleCommits[i];
+        const actualIndex = scrollOffset + i;
+        const isSelected = actualIndex === selectedIndex;
+        const isHighlighted = isSelected && isFocused;
+        const dateStr = formatDate(commit.date);
+        // Fixed parts: hash(7) + spaces(4) + date + parens(2) + selection indicator(2)
+        const baseWidth = 7 + 4 + dateStr.length + 2 + 2;
+        const remainingWidth = Math.max(10, width - baseWidth);
+        const { displayMessage, displayRefs } = formatCommitDisplay(commit.message, commit.refs, remainingWidth);
+        let line = '';
+        // Selection indicator
+        if (isHighlighted) {
+            line += '{cyan-fg}{bold}▸ {/bold}{/cyan-fg}';
+        }
+        else {
+            line += '  ';
+        }
+        // Short hash
+        line += `{yellow-fg}${commit.shortHash}{/yellow-fg} `;
+        // Message (with highlighting)
+        if (isHighlighted) {
+            line += `{cyan-fg}{inverse}${escapeContent(displayMessage)}{/inverse}{/cyan-fg}`;
+        }
+        else {
+            line += escapeContent(displayMessage);
+        }
+        // Date
+        line += ` {gray-fg}(${dateStr}){/gray-fg}`;
+        // Refs (branch names, tags)
+        if (displayRefs) {
+            line += ` {green-fg}${escapeContent(displayRefs)}{/green-fg}`;
+        }
+        lines.push(line);
+    }
+    return lines.join('\n');
+}
+/**
+ * Escape blessed tags in content.
+ */
+function escapeContent(content) {
+    return content.replace(/\{/g, '{{').replace(/\}/g, '}}');
+}
+/**
+ * Get the total number of rows in the history view (for scroll calculation).
+ */
+export function getHistoryTotalRows(commits) {
+    return commits.length;
+}
+/**
+ * Get the commit at a specific index.
+ */
+export function getCommitAtIndex(commits, index) {
+    return commits[index] ?? null;
+}

package/dist/utils/ansiToBlessed.js

@@ -0,0 +1,125 @@
+/**
+ * Convert ANSI escape codes to blessed tags.
+ * Supports basic foreground colors and styles.
+ */
+// ANSI color code to blessed color name mapping
+const ANSI_FG_COLORS = {
+    30: 'black',
+    31: 'red',
+    32: 'green',
+    33: 'yellow',
+    34: 'blue',
+    35: 'magenta',
+    36: 'cyan',
+    37: 'white',
+    90: 'gray',
+    91: 'red',
+    92: 'green',
+    93: 'yellow',
+    94: 'blue',
+    95: 'magenta',
+    96: 'cyan',
+    97: 'white',
+};
+/**
+ * Escape blessed tags in plain text.
+ */
+function escapeBlessed(text) {
+    return text.replace(/\{/g, '{{').replace(/\}/g, '}}');
+}
+/**
+ * Convert ANSI escape sequences to blessed tags.
+ *
+ * @param input - String containing ANSI escape codes
+ * @returns String with blessed tags
+ */
+export function ansiToBlessed(input) {
+    if (!input)
+        return '';
+    // Track current styles
+    const activeStyles = [];
+    let result = '';
+    let i = 0;
+    while (i < input.length) {
+        // Check for ANSI escape sequence
+        if (input[i] === '\x1b' && input[i + 1] === '[') {
+            // Find the end of the sequence (look for 'm')
+            let j = i + 2;
+            while (j < input.length && input[j] !== 'm') {
+                j++;
+            }
+            if (input[j] === 'm') {
+                // Parse the codes
+                const codes = input
+                    .slice(i + 2, j)
+                    .split(';')
+                    .map(Number);
+                for (const code of codes) {
+                    if (code === 0) {
+                        // Reset - close all active styles
+                        while (activeStyles.length > 0) {
+                            const style = activeStyles.pop();
+                            if (style) {
+                                result += `{/${style}}`;
+                            }
+                        }
+                    }
+                    else if (code === 1) {
+                        // Bold
+                        activeStyles.push('bold');
+                        result += '{bold}';
+                    }
+                    else if (code === 2) {
+                        // Dim/faint - blessed doesn't have direct support, use gray
+                        activeStyles.push('gray-fg');
+                        result += '{gray-fg}';
+                    }
+                    else if (code === 3) {
+                        // Italic - not well supported in terminals, skip
+                    }
+                    else if (code === 4) {
+                        // Underline
+                        activeStyles.push('underline');
+                        result += '{underline}';
+                    }
+                    else if (code >= 30 && code <= 37) {
+                        // Standard foreground colors
+                        const color = ANSI_FG_COLORS[code];
+                        if (color) {
+                            activeStyles.push(`${color}-fg`);
+                            result += `{${color}-fg}`;
+                        }
+                    }
+                    else if (code >= 90 && code <= 97) {
+                        // Bright foreground colors
+                        const color = ANSI_FG_COLORS[code];
+                        if (color) {
+                            activeStyles.push(`${color}-fg`);
+                            result += `{${color}-fg}`;
+                        }
+                    }
+                    // Note: We ignore background colors (40-47, 100-107) for simplicity
+                }
+                i = j + 1;
+                continue;
+            }
+        }
+        // Regular character - escape if needed and append
+        const char = input[i];
+        if (char === '{' || char === '}') {
+            result += char + char;
+        }
+        else {
+            result += char;
+        }
+        i++;
+    }
+    // Close any remaining active styles
+    while (activeStyles.length > 0) {
+        const style = activeStyles.pop();
+        if (style) {
+            result += `{/${style}}`;
+        }
+    }
+    return result;
+}

package/dist/utils/ansiTruncate.js

@@ -0,0 +1,108 @@
+/**
+ * ANSI-aware string truncation utility.
+ *
+ * Truncates strings containing ANSI escape codes at a visual character limit
+ * while preserving formatting up to the truncation point.
+ */
+// ANSI escape sequence pattern: ESC [ ... m
+// Matches sequences like \x1b[32m, \x1b[0m, \x1b[1;34m, etc.
+const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+// ANSI reset sequence to clear all formatting
+const ANSI_RESET = '\x1b[0m';
+/**
+ * Calculate the visual length of a string (excluding ANSI codes).
+ */
+export function visualLength(str) {
+    return str.replace(ANSI_PATTERN, '').length;
+}
+/**
+ * Truncate a string with ANSI codes at a visual character limit.
+ *
+ * @param str - String potentially containing ANSI escape codes
+ * @param maxVisualLength - Maximum visual characters (not counting ANSI codes)
+ * @param suffix - Suffix to append when truncated (default: '…')
+ * @returns Truncated string with ANSI reset if needed
+ */
+export function truncateAnsi(str, maxVisualLength, suffix = '…') {
+    if (maxVisualLength <= 0) {
+        return suffix;
+    }
+    // Quick check: if no ANSI codes and short enough, return as-is
+    if (!str.includes('\x1b') && str.length <= maxVisualLength) {
+        return str;
+    }
+    // If no ANSI codes, simple truncation
+    if (!str.includes('\x1b')) {
+        if (str.length <= maxVisualLength) {
+            return str;
+        }
+        return str.slice(0, maxVisualLength - suffix.length) + suffix;
+    }
+    // Parse string into segments: either ANSI codes or visible text
+    const segments = [];
+    let lastIndex = 0;
+    // Reset the regex state
+    ANSI_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = ANSI_PATTERN.exec(str)) !== null) {
+        // Add text before this ANSI code
+        if (match.index > lastIndex) {
+            segments.push({ type: 'text', content: str.slice(lastIndex, match.index) });
+        }
+        // Add the ANSI code
+        segments.push({ type: 'ansi', content: match[0] });
+        lastIndex = match.index + match[0].length;
+    }
+    // Add remaining text after last ANSI code
+    if (lastIndex < str.length) {
+        segments.push({ type: 'text', content: str.slice(lastIndex) });
+    }
+    // Build result, tracking visual length
+    let result = '';
+    let currentVisualLength = 0;
+    const targetLength = maxVisualLength - suffix.length;
+    let hasAnsiCodes = false;
+    let truncated = false;
+    for (const segment of segments) {
+        if (segment.type === 'ansi') {
+            // Always include ANSI codes (they don't take visual space)
+            result += segment.content;
+            hasAnsiCodes = true;
+        }
+        else {
+            // Text segment - check if it fits
+            const remainingSpace = targetLength - currentVisualLength;
+            if (remainingSpace <= 0) {
+                // No more space
+                truncated = true;
+                break;
+            }
+            if (segment.content.length <= remainingSpace) {
+                // Entire segment fits
+                result += segment.content;
+                currentVisualLength += segment.content.length;
+            }
+            else {
+                // Partial fit - truncate this segment
+                result += segment.content.slice(0, remainingSpace);
+                currentVisualLength += remainingSpace;
+                truncated = true;
+                break;
+            }
+        }
+    }
+    if (truncated) {
+        // Reset formatting before suffix to ensure clean state
+        if (hasAnsiCodes) {
+            result += ANSI_RESET;
+        }
+        result += suffix;
+    }
+    return result;
+}
+/**
+ * Check if a string needs truncation at the given visual length.
+ */
+export function needsTruncation(str, maxVisualLength) {
+    return visualLength(str) > maxVisualLength;
+}

package/dist/utils/baseBranchCache.js

@@ -1,2 +1,44 @@
-import*as n from"node:fs";import*as c from"node:path";import*as i from"node:os";const t=c.join(i.homedir(),".cache","diffstalker","base-branches.json");function h(){const e=c.dirname(t);n.existsSync(e)||n.mkdirSync(e,{recursive:!0})}function s(){try{if(n.existsSync(t))return JSON.parse(n.readFileSync(t,"utf-8"))}catch{}return{}}function f(e){h(),n.writeFileSync(t,JSON.stringify(e,null,2)+`
-`)}export function getCachedBaseBranch(e){const a=s(),r=c.resolve(e);return a[r]}export function setCachedBaseBranch(e,a){const r=s(),o=c.resolve(e);r[o]=a,f(r)}
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+const CACHE_PATH = path.join(os.homedir(), '.cache', 'diffstalker', 'base-branches.json');
+function ensureCacheDir() {
+    const dir = path.dirname(CACHE_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function loadCache() {
+    try {
+        if (fs.existsSync(CACHE_PATH)) {
+            return JSON.parse(fs.readFileSync(CACHE_PATH, 'utf-8'));
+        }
+    }
+    catch {
+        // Ignore read errors, return empty cache
+    }
+    return {};
+}
+function saveCache(cache) {
+    ensureCacheDir();
+    fs.writeFileSync(CACHE_PATH, JSON.stringify(cache, null, 2) + '\n');
+}
+/**
+ * Get the cached base branch for a repository.
+ * Returns undefined if no cached value exists.
+ */
+export function getCachedBaseBranch(repoPath) {
+    const cache = loadCache();
+    // Normalize path for consistent lookup
+    const normalizedPath = path.resolve(repoPath);
+    return cache[normalizedPath];
+}
+/**
+ * Save the selected base branch for a repository to the cache.
+ */
+export function setCachedBaseBranch(repoPath, baseBranch) {
+    const cache = loadCache();
+    const normalizedPath = path.resolve(repoPath);
+    cache[normalizedPath] = baseBranch;
+    saveCache(cache);
+}

package/dist/utils/commitFormat.js

@@ -1 +1,38 @@
-export function truncateWithEllipsis(t,s){return t.length<=s?t:s<=3?t.slice(0,s):t.slice(0,s-3)+"..."}export function formatCommitDisplay(t,s,n,l=20){const r=s||"",i=Math.max(0,n-l-1);let e=r;e.length>i&&i>3?e=e.slice(0,i-3)+"...":e.length>i&&(e="");const c=e?e.length+1:0,f=Math.max(l,n-c);return{displayMessage:truncateWithEllipsis(t,f),displayRefs:e}}
+/**
+ * Truncate a string with ellipsis if it exceeds maxLength.
+ */
+export function truncateWithEllipsis(str, maxLength) {
+    if (str.length <= maxLength)
+        return str;
+    if (maxLength <= 3)
+        return str.slice(0, maxLength);
+    return str.slice(0, maxLength - 3) + '...';
+}
+/**
+ * Format commit message and refs for display within available width.
+ * Prioritizes message over refs, truncating refs first if needed.
+ *
+ * @param message - The commit message
+ * @param refs - The commit refs (branch names, tags)
+ * @param availableWidth - Total width available for message + refs
+ * @param minMessageWidth - Minimum width to reserve for message (default: 20)
+ */
+export function formatCommitDisplay(message, refs, availableWidth, minMessageWidth = 20) {
+    const refsStr = refs || '';
+    // Calculate max space for refs (leave at least minMessageWidth for message + 1 for space)
+    const maxRefsWidth = Math.max(0, availableWidth - minMessageWidth - 1);
+    // Truncate refs if needed
+    let displayRefs = refsStr;
+    if (displayRefs.length > maxRefsWidth && maxRefsWidth > 3) {
+        displayRefs = displayRefs.slice(0, maxRefsWidth - 3) + '...';
+    }
+    else if (displayRefs.length > maxRefsWidth) {
+        displayRefs = ''; // Not enough space for refs
+    }
+    // Calculate message width (remaining space after refs)
+    const refsWidth = displayRefs ? displayRefs.length + 1 : 0; // +1 for space before refs
+    const messageWidth = Math.max(minMessageWidth, availableWidth - refsWidth);
+    // Truncate message if needed
+    const displayMessage = truncateWithEllipsis(message, messageWidth);
+    return { displayMessage, displayRefs };
+}

package/dist/utils/diffFilters.js

@@ -1 +1,21 @@
-export function isDisplayableDiffHeader(i){return!(i.startsWith("index ")||i.startsWith("--- ")||i.startsWith("+++ ")||i.startsWith("similarity index"))}export function isDisplayableDiffLine(i){return i.type!=="header"?!0:isDisplayableDiffHeader(i.content)}
+/**
+ * Check if a diff header line should be displayed.
+ * Filters out redundant headers like index, ---, +++, and similarity index.
+ * This is used consistently across DiffView, CompareView, and HistoryDiffView.
+ */
+export function isDisplayableDiffHeader(content) {
+    return !(content.startsWith('index ') ||
+        content.startsWith('--- ') ||
+        content.startsWith('+++ ') ||
+        content.startsWith('similarity index'));
+}
+/**
+ * Check if a diff line should be displayed.
+ * Non-header lines are always displayed.
+ * Header lines are filtered using isDisplayableDiffHeader.
+ */
+export function isDisplayableDiffLine(line) {
+    if (line.type !== 'header')
+        return true;
+    return isDisplayableDiffHeader(line.content);
+}