diffstalker 0.1.7 → 0.2.0

package/dist/hooks/useLayout.js

@@ -1,154 +0,0 @@
-import { useState, useEffect, useMemo, useCallback } from 'react';
-import { getRowForFileIndex, calculateScrollOffset, getFileListSectionCounts, getFileListTotalRows, } from '../utils/layoutCalculations.js';
-import { calculatePaneBoundaries } from '../utils/mouseCoordinates.js';
-import { getMaxScrollOffset } from '../components/ScrollableList.js';
-// Layout constants (compact: single-line separators)
-// Header (1) + sep (1) + sep (1) + sep (1) + footer (1) = 5 lines overhead
-// Note: Header can be 2 lines when follow indicator causes branch to wrap
-export const LAYOUT_OVERHEAD = 5;
-// Default split ratios for different modes
-const DEFAULT_SPLIT_RATIOS = {
-    diff: 0.4, // 40% top pane for staging area
-    commit: 0.4, // 40% top pane for staging area
-    history: 0.5, // 50% top pane for commit list (larger default)
-    compare: 0.5, // 50% top pane for compare list (larger default)
-    explorer: 0.4, // 40% top pane for file listing
-};
-// Step size for keyboard-based pane resizing (5% per keypress)
-export const SPLIT_RATIO_STEP = 0.05;
-export function useLayout(terminalHeight, terminalWidth, files, selectedIndex, diff, mode = 'diff', historySelectedIndex, initialSplitRatio, extraOverhead = 0) {
-    // Calculate content height (terminal minus overhead)
-    const contentHeight = terminalHeight - LAYOUT_OVERHEAD - extraOverhead;
-    // Custom split ratio state (null means use default for mode)
-    const [customSplitRatio, setCustomSplitRatio] = useState(initialSplitRatio ?? null);
-    // Get the effective split ratio
-    const effectiveSplitRatio = customSplitRatio ?? DEFAULT_SPLIT_RATIOS[mode];
-    // Calculate pane heights based on custom ratio or mode default
-    const { topPaneHeight, bottomPaneHeight } = useMemo(() => {
-        // Apply the split ratio directly
-        const minHeight = 5;
-        const maxHeight = contentHeight - minHeight; // Leave at least minHeight for bottom pane
-        const targetHeight = Math.floor(contentHeight * effectiveSplitRatio);
-        const topHeight = Math.max(minHeight, Math.min(targetHeight, maxHeight));
-        const bottomHeight = contentHeight - topHeight;
-        return { topPaneHeight: topHeight, bottomPaneHeight: bottomHeight };
-    }, [contentHeight, effectiveSplitRatio]);
-    // Setter for split ratio with bounds checking
-    const setSplitRatio = useCallback((ratio) => {
-        // Clamp ratio between 0.15 and 0.85 to ensure both panes remain usable
-        const clampedRatio = Math.max(0.15, Math.min(0.85, ratio));
-        setCustomSplitRatio(clampedRatio);
-    }, []);
-    // Adjust split ratio by delta (for keyboard-based resizing)
-    const adjustSplitRatio = useCallback((delta) => {
-        const currentRatio = customSplitRatio ?? DEFAULT_SPLIT_RATIOS[mode];
-        const newRatio = Math.max(0.15, Math.min(0.85, currentRatio + delta));
-        setCustomSplitRatio(newRatio);
-    }, [customSplitRatio, mode]);
-    // Expose current split ratio
-    const splitRatio = effectiveSplitRatio;
-    // Calculate pane boundaries for mouse handling
-    // extraOverhead = headerHeight - 1, so headerHeight = extraOverhead + 1
-    const headerHeight = extraOverhead + 1;
-    const paneBoundaries = useMemo(() => calculatePaneBoundaries(topPaneHeight, bottomPaneHeight, terminalHeight, headerHeight), [topPaneHeight, bottomPaneHeight, terminalHeight, headerHeight]);
-    // Scroll state
-    const [fileListScrollOffset, setFileListScrollOffset] = useState(0);
-    const [diffScrollOffset, setDiffScrollOffset] = useState(0);
-    const [historyScrollOffset, setHistoryScrollOffset] = useState(0);
-    const [compareScrollOffset, setCompareScrollOffset] = useState(0);
-    // Reset file list scroll when files change
-    useEffect(() => {
-        setFileListScrollOffset(0);
-    }, [files.length]);
-    // Reset diff scroll when diff changes
-    useEffect(() => {
-        setDiffScrollOffset(0);
-    }, [diff]);
-    // Auto-scroll file list to keep selected item visible (only when selection changes)
-    useEffect(() => {
-        const { modifiedCount, untrackedCount, stagedCount } = getFileListSectionCounts(files);
-        const selectedRow = getRowForFileIndex(selectedIndex, modifiedCount, untrackedCount, stagedCount);
-        const visibleHeight = topPaneHeight - 1;
-        setFileListScrollOffset((prev) => {
-            const newOffset = calculateScrollOffset(selectedRow, prev, visibleHeight);
-            return newOffset;
-        });
-    }, [selectedIndex, files, topPaneHeight]);
-    // Scroll helpers
-    const scrollDiff = useCallback((direction, amount = 3, totalRows = 0) => {
-        // Simple: totalRows = displayRows.length (every row = 1 terminal row)
-        // Match ScrollableList's available height calculation:
-        // - DiffView receives maxHeight = bottomPaneHeight - 1 (BottomPane header)
-        // - ScrollableList reserves 2 rows for indicators when content needs scrolling
-        const diffViewMaxHeight = bottomPaneHeight - 1;
-        const needsScrolling = totalRows > diffViewMaxHeight;
-        const availableAtMaxScroll = needsScrolling ? diffViewMaxHeight - 2 : diffViewMaxHeight;
-        const maxOffset = Math.max(0, totalRows - availableAtMaxScroll);
-        setDiffScrollOffset((prev) => {
-            if (direction === 'up') {
-                return Math.max(0, prev - amount);
-            }
-            else {
-                return Math.min(maxOffset, prev + amount);
-            }
-        });
-    }, [bottomPaneHeight]);
-    const scrollFileList = useCallback((direction, amount = 3) => {
-        const totalRows = getFileListTotalRows(files);
-        const visibleRows = topPaneHeight - 1;
-        const maxScroll = Math.max(0, totalRows - visibleRows);
-        setFileListScrollOffset((prev) => {
-            if (direction === 'up') {
-                return Math.max(0, prev - amount);
-            }
-            else {
-                return Math.min(maxScroll, prev + amount);
-            }
-        });
-    }, [files, topPaneHeight]);
-    const scrollHistory = useCallback((direction, totalItems = 0, amount = 3) => {
-        // History is in top pane, maxHeight is topPaneHeight - 1 for "COMMITS" header
-        const maxOffset = getMaxScrollOffset(totalItems, topPaneHeight - 1);
-        setHistoryScrollOffset((prev) => {
-            if (direction === 'up') {
-                return Math.max(0, prev - amount);
-            }
-            else {
-                return Math.min(maxOffset, prev + amount);
-            }
-        });
-    }, [topPaneHeight]);
-    const scrollCompare = useCallback((direction, totalRows, amount = 3) => {
-        // Compare list is in top pane, maxHeight is topPaneHeight - 1 for "COMPARE" header
-        const maxOffset = getMaxScrollOffset(totalRows, topPaneHeight - 1);
-        setCompareScrollOffset((prev) => {
-            if (direction === 'up') {
-                return Math.max(0, prev - amount);
-            }
-            else {
-                return Math.min(maxOffset, prev + amount);
-            }
-        });
-    }, [topPaneHeight]);
-    return {
-        topPaneHeight,
-        bottomPaneHeight,
-        contentHeight,
-        paneBoundaries,
-        splitRatio,
-        setSplitRatio,
-        adjustSplitRatio,
-        fileListScrollOffset,
-        diffScrollOffset,
-        historyScrollOffset,
-        compareScrollOffset,
-        setFileListScrollOffset,
-        setDiffScrollOffset,
-        setHistoryScrollOffset,
-        setCompareScrollOffset,
-        scrollDiff,
-        scrollFileList,
-        scrollHistory,
-        scrollCompare,
-    };
-}

package/dist/hooks/useMouse.js

@@ -1,87 +0,0 @@
-import { useEffect, useState, useCallback, useRef } from 'react';
-import { useStdin } from 'ink';
-export function useMouse(onEvent, disabled = false) {
-    const { stdin, setRawMode } = useStdin();
-    const [mouseEnabled, setMouseEnabled] = useState(true);
-    const onEventRef = useRef(onEvent);
-    useEffect(() => {
-        onEventRef.current = onEvent;
-    });
-    const toggleMouse = useCallback(() => {
-        setMouseEnabled((prev) => !prev);
-    }, []);
-    // Store mouseEnabled in ref for use in event handler
-    const mouseEnabledRef = useRef(mouseEnabled);
-    useEffect(() => {
-        mouseEnabledRef.current = mouseEnabled;
-    }, [mouseEnabled]);
-    // Handle mouse mode changes
-    // When disabled (text input focused) or in select mode, disable mouse tracking for text selection
-    useEffect(() => {
-        if (!disabled && mouseEnabled) {
-            process.stdout.write('\x1b[?1000h');
-            process.stdout.write('\x1b[?1006h');
-        }
-        else {
-            process.stdout.write('\x1b[?1006l');
-            process.stdout.write('\x1b[?1000l');
-        }
-    }, [disabled, mouseEnabled]);
-    // Set up event listener (separate from mode toggle)
-    useEffect(() => {
-        if (!stdin || !setRawMode)
-            return;
-        const handleData = (data) => {
-            const str = data.toString();
-            // Parse SGR mouse events: \x1b[<button;x;y[Mm]
-            // eslint-disable-next-line no-control-regex
-            const sgrMatch = str.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
-            if (sgrMatch) {
-                const buttonCode = parseInt(sgrMatch[1], 10);
-                const x = parseInt(sgrMatch[2], 10);
-                const y = parseInt(sgrMatch[3], 10);
-                const isRelease = sgrMatch[4] === 'm';
-                // Scroll wheel events (button codes 64-67) - only when in scroll mode
-                if (buttonCode >= 64 && buttonCode < 96) {
-                    if (mouseEnabledRef.current) {
-                        const type = buttonCode === 64 ? 'scroll-up' : 'scroll-down';
-                        onEventRef.current({ x, y, type, button: 'none' });
-                    }
-                }
-                // Click events (button codes 0-2) - only on release to avoid double-firing
-                else if (isRelease && buttonCode >= 0 && buttonCode < 3) {
-                    const button = buttonCode === 0 ? 'left' : buttonCode === 1 ? 'middle' : 'right';
-                    onEventRef.current({ x, y, type: 'click', button });
-                }
-                return;
-            }
-            // Parse legacy mouse events
-            // eslint-disable-next-line no-control-regex
-            const legacyMatch = str.match(/\x1b\[M(.)(.)(.)/);
-            if (legacyMatch) {
-                const buttonCode = legacyMatch[1].charCodeAt(0) - 32;
-                const x = legacyMatch[2].charCodeAt(0) - 32;
-                const y = legacyMatch[3].charCodeAt(0) - 32;
-                if (buttonCode >= 64) {
-                    if (mouseEnabledRef.current) {
-                        const type = buttonCode === 64 ? 'scroll-up' : 'scroll-down';
-                        onEventRef.current({ x, y, type, button: 'none' });
-                    }
-                }
-                // Legacy click events (button codes 0-2)
-                else if (buttonCode >= 0 && buttonCode < 3) {
-                    const button = buttonCode === 0 ? 'left' : buttonCode === 1 ? 'middle' : 'right';
-                    onEventRef.current({ x, y, type: 'click', button });
-                }
-            }
-        };
-        stdin.on('data', handleData);
-        return () => {
-            stdin.off('data', handleData);
-            // Disable mouse tracking on unmount
-            process.stdout.write('\x1b[?1006l');
-            process.stdout.write('\x1b[?1000l');
-        };
-    }, [stdin, setRawMode]);
-    return { mouseEnabled, toggleMouse };
-}

package/dist/hooks/useTerminalSize.js

@@ -1,20 +0,0 @@
-import { useState, useEffect } from 'react';
-export function useTerminalSize() {
-    const [size, setSize] = useState({
-        rows: process.stdout.rows ?? 24,
-        columns: process.stdout.columns ?? 80,
-    });
-    useEffect(() => {
-        const handleResize = () => {
-            setSize({
-                rows: process.stdout.rows ?? 24,
-                columns: process.stdout.columns ?? 80,
-            });
-        };
-        process.stdout.on('resize', handleResize);
-        return () => {
-            process.stdout.off('resize', handleResize);
-        };
-    }, []);
-    return size;
-}

package/dist/hooks/useWatcher.js

@@ -1,137 +0,0 @@
-import { useState, useEffect, useRef } from 'react';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { watch } from 'chokidar';
-import { ensureTargetDir } from '../config.js';
-function expandPath(p) {
-    // Expand ~ to home directory
-    if (p.startsWith('~/')) {
-        return path.join(os.homedir(), p.slice(2));
-    }
-    if (p === '~') {
-        return os.homedir();
-    }
-    return p;
-}
-function getLastNonEmptyLine(content) {
-    // Support append-only files by reading only the last non-empty line
-    const lines = content.split('\n');
-    for (let i = lines.length - 1; i >= 0; i--) {
-        const line = lines[i].trim();
-        if (line)
-            return line;
-    }
-    return '';
-}
-export function useWatcher(initialEnabled, targetFile, debug = false) {
-    const [enabled, setEnabled] = useState(initialEnabled);
-    const [state, setState] = useState({
-        path: null,
-        lastUpdate: null,
-        rawContent: null,
-        sourceFile: initialEnabled ? targetFile : null,
-        enabled: initialEnabled,
-    });
-    const debounceTimer = useRef(null);
-    const lastReadPath = useRef(null);
-    // Update state when enabled changes
-    useEffect(() => {
-        setState((prev) => ({
-            ...prev,
-            enabled,
-            sourceFile: enabled ? targetFile : null,
-        }));
-    }, [enabled, targetFile]);
-    useEffect(() => {
-        // If watcher is disabled, do nothing
-        if (!enabled) {
-            return;
-        }
-        // Ensure the directory exists
-        ensureTargetDir(targetFile);
-        // Create the file if it doesn't exist
-        if (!fs.existsSync(targetFile)) {
-            fs.writeFileSync(targetFile, '');
-        }
-        // Read and set target path with debouncing
-        const readTarget = () => {
-            // Clear any pending debounce
-            if (debounceTimer.current) {
-                clearTimeout(debounceTimer.current);
-            }
-            debounceTimer.current = setTimeout(() => {
-                try {
-                    const raw = fs.readFileSync(targetFile, 'utf-8');
-                    const content = getLastNonEmptyLine(raw);
-                    if (content && content !== lastReadPath.current) {
-                        // Expand ~ and resolve to absolute path
-                        const expanded = expandPath(content);
-                        const resolved = path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
-                        const now = new Date();
-                        if (debug) {
-                            process.stderr.write(`[diffstalker ${now.toISOString()}] Path change detected\n`);
-                            process.stderr.write(`  Source file: ${targetFile}\n`);
-                            process.stderr.write(`  Raw content: "${content}"\n`);
-                            process.stderr.write(`  Previous:    "${lastReadPath.current ?? '(none)'}"\n`);
-                            process.stderr.write(`  Resolved:    "${resolved}"\n`);
-                        }
-                        lastReadPath.current = resolved;
-                        setState({
-                            path: resolved,
-                            lastUpdate: now,
-                            rawContent: content,
-                            sourceFile: targetFile,
-                            enabled: true,
-                        });
-                    }
-                }
-                catch {
-                    // Ignore read errors
-                }
-            }, 100);
-        };
-        // Read initial value immediately (no debounce for first read)
-        try {
-            const raw = fs.readFileSync(targetFile, 'utf-8');
-            const content = getLastNonEmptyLine(raw);
-            if (content) {
-                // Expand ~ and resolve to absolute path
-                const expanded = expandPath(content);
-                const resolved = path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
-                const now = new Date();
-                if (debug) {
-                    process.stderr.write(`[diffstalker ${now.toISOString()}] Initial path read\n`);
-                    process.stderr.write(`  Source file: ${targetFile}\n`);
-                    process.stderr.write(`  Raw content: "${content}"\n`);
-                    process.stderr.write(`  Resolved:    "${resolved}"\n`);
-                }
-                lastReadPath.current = resolved;
-                setState({
-                    path: resolved,
-                    lastUpdate: now,
-                    rawContent: content,
-                    sourceFile: targetFile,
-                    enabled: true,
-                });
-            }
-        }
-        catch {
-            // Ignore read errors
-        }
-        // Watch for changes
-        const watcher = watch(targetFile, {
-            persistent: true,
-            ignoreInitial: true,
-        });
-        watcher.on('change', readTarget);
-        watcher.on('add', readTarget);
-        return () => {
-            if (debounceTimer.current) {
-                clearTimeout(debounceTimer.current);
-            }
-            watcher.close();
-        };
-    }, [enabled, targetFile, debug]);
-    return { state, setEnabled };
-}