snow-ai 0.4.16 → 0.4.17

package/dist/ui/components/DiffViewer.js

@@ -1,178 +0,0 @@
-import React, { useMemo } from 'react';
-import { Box, Text } from 'ink';
-import * as Diff from 'diff';
-import { useTheme } from '../contexts/ThemeContext.js';
-// Helper function to strip line numbers from content (format: "123→content")
-function stripLineNumbers(content) {
-    return content
-        .split('\n')
-        .map(line => {
-        // Match pattern: digits + → + content
-        const match = line.match(/^\s*\d+→(.*)$/);
-        return match ? match[1] : line;
-    })
-        .join('\n');
-}
-export default function DiffViewer({ oldContent = '', newContent, filename, completeOldContent, completeNewContent, startLineNumber = 1, }) {
-    const { theme } = useTheme();
-    // If complete file contents are provided, use them for intelligent diff
-    const useCompleteContent = completeOldContent && completeNewContent;
-    const diffOldContent = useCompleteContent
-        ? completeOldContent
-        : stripLineNumbers(oldContent);
-    const diffNewContent = useCompleteContent
-        ? completeNewContent
-        : stripLineNumbers(newContent);
-    // If no old content, show as new file creation
-    const isNewFile = !diffOldContent || diffOldContent.trim() === '';
-    // Memoize new file rendering to avoid re-splitting lines on every render
-    const newFileContent = useMemo(() => {
-        if (!isNewFile)
-            return null;
-        const allLines = diffNewContent.split('\n');
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, { bold: true, color: "green" }, "[New File]"),
-                filename && React.createElement(Text, { color: "cyan" },
-                    " ",
-                    filename)),
-            React.createElement(Box, { flexDirection: "column" }, allLines.map((line, index) => (React.createElement(Text, { key: index, color: "white", backgroundColor: theme.colors.diffAdded },
-                "+ ",
-                line))))));
-    }, [isNewFile, diffNewContent, filename, theme.colors.text, theme.colors.diffAdded]);
-    if (isNewFile) {
-        return newFileContent;
-    }
-    // Memoize expensive diff calculation - only recompute when content changes
-    const hunks = useMemo(() => {
-        // Generate line-by-line diff
-        const diffResult = Diff.diffLines(diffOldContent, diffNewContent);
-        const allChanges = [];
-        let oldLineNum = startLineNumber;
-        let newLineNum = startLineNumber;
-        diffResult.forEach(part => {
-            const lines = part.value.replace(/\n$/, '').split('\n');
-            lines.forEach(line => {
-                if (part.added) {
-                    allChanges.push({
-                        type: 'added',
-                        content: line,
-                        oldLineNum: null,
-                        newLineNum: newLineNum++,
-                    });
-                }
-                else if (part.removed) {
-                    allChanges.push({
-                        type: 'removed',
-                        content: line,
-                        oldLineNum: oldLineNum++,
-                        newLineNum: null,
-                    });
-                }
-                else {
-                    allChanges.push({
-                        type: 'unchanged',
-                        content: line,
-                        oldLineNum: oldLineNum++,
-                        newLineNum: newLineNum++,
-                    });
-                }
-            });
-        });
-        // Find diff hunks (groups of changes with context)
-        const computedHunks = [];
-        const contextLines = 3; // Number of context lines before and after changes
-        for (let i = 0; i < allChanges.length; i++) {
-            const change = allChanges[i];
-            if (change?.type !== 'unchanged') {
-                // Found a change, create a hunk
-                const hunkStart = Math.max(0, i - contextLines);
-                let hunkEnd = i;
-                // Extend the hunk to include all consecutive changes
-                while (hunkEnd < allChanges.length - 1) {
-                    const nextChange = allChanges[hunkEnd + 1];
-                    if (!nextChange)
-                        break;
-                    // If next line is a change, extend the hunk
-                    if (nextChange.type !== 'unchanged') {
-                        hunkEnd++;
-                        continue;
-                    }
-                    // If there are more changes within context distance, extend the hunk
-                    let hasMoreChanges = false;
-                    for (let j = hunkEnd + 1; j < Math.min(allChanges.length, hunkEnd + 1 + contextLines * 2); j++) {
-                        if (allChanges[j]?.type !== 'unchanged') {
-                            hasMoreChanges = true;
-                            break;
-                        }
-                    }
-                    if (hasMoreChanges) {
-                        hunkEnd++;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                // Add context lines after the hunk
-                hunkEnd = Math.min(allChanges.length - 1, hunkEnd + contextLines);
-                // Extract the hunk
-                const hunkChanges = allChanges.slice(hunkStart, hunkEnd + 1);
-                const firstChange = hunkChanges[0];
-                const lastChange = hunkChanges[hunkChanges.length - 1];
-                if (firstChange && lastChange) {
-                    computedHunks.push({
-                        startLine: firstChange.oldLineNum || firstChange.newLineNum || 1,
-                        endLine: lastChange.oldLineNum || lastChange.newLineNum || 1,
-                        changes: hunkChanges,
-                    });
-                }
-                // Skip to the end of this hunk
-                i = hunkEnd;
-            }
-        }
-        return computedHunks;
-    }, [diffOldContent, diffNewContent, startLineNumber]);
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "yellow" }, "[File Modified]"),
-            filename && React.createElement(Text, { color: "cyan" },
-                " ",
-                filename)),
-        React.createElement(Box, { flexDirection: "column" },
-            hunks.map((hunk, hunkIndex) => (React.createElement(Box, { key: hunkIndex, flexDirection: "column", marginBottom: 1 },
-                React.createElement(Text, { color: "cyan", dimColor: true },
-                    "@@ Lines ",
-                    hunk.startLine,
-                    "-",
-                    hunk.endLine,
-                    " @@"),
-                hunk.changes.map((change, changeIndex) => {
-                    // Calculate line number to display
-                    const lineNum = change.type === 'added' ? change.newLineNum : change.oldLineNum;
-                    const lineNumStr = lineNum
-                        ? String(lineNum).padStart(4, ' ')
-                        : '    ';
-                    if (change.type === 'added') {
-                        return (React.createElement(Text, { key: changeIndex, color: "white", backgroundColor: theme.colors.diffAdded },
-                            lineNumStr,
-                            " + ",
-                            change.content));
-                    }
-                    if (change.type === 'removed') {
-                        return (React.createElement(Text, { key: changeIndex, color: "white", backgroundColor: theme.colors.diffRemoved },
-                            lineNumStr,
-                            " - ",
-                            change.content));
-                    }
-                    // Unchanged lines (context)
-                    return (React.createElement(Text, { key: changeIndex, dimColor: true },
-                        lineNumStr,
-                        " ",
-                        change.content));
-                })))),
-            hunks.length > 1 && (React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { color: "gray", dimColor: true },
-                    "Total: ",
-                    hunks.length,
-                    " change region(s)"))))));
-}

package/dist/ui/components/FileList.d.ts

@@ -1,15 +0,0 @@
-import React from 'react';
-type Props = {
-    query: string;
-    selectedIndex: number;
-    visible: boolean;
-    maxItems?: number;
-    rootPath?: string;
-    onFilteredCountChange?: (count: number) => void;
-    searchMode?: 'file' | 'content';
-};
-export type FileListRef = {
-    getSelectedFile: () => string | null;
-};
-declare const FileList: React.MemoExoticComponent<React.ForwardRefExoticComponent<Props & React.RefAttributes<FileListRef>>>;
-export default FileList;

package/dist/ui/components/FileList.js

@@ -1,360 +0,0 @@
-import React, { useState, useEffect, useMemo, useCallback, forwardRef, useImperativeHandle, memo, } from 'react';
-import { Box, Text } from 'ink';
-import fs from 'fs';
-import path from 'path';
-import { useTerminalSize } from '../../hooks/useTerminalSize.js';
-import { useTheme } from '../contexts/ThemeContext.js';
-const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10, rootPath = process.cwd(), onFilteredCountChange, searchMode = 'file', }, ref) => {
-    const { theme } = useTheme();
-    const [files, setFiles] = useState([]);
-    const [isLoading, setIsLoading] = useState(false);
-    // Get terminal size for dynamic content display
-    const { columns: terminalWidth } = useTerminalSize();
-    // Fixed maximum display items to prevent rendering issues
-    const MAX_DISPLAY_ITEMS = 5;
-    const effectiveMaxItems = useMemo(() => {
-        return maxItems
-            ? Math.min(maxItems, MAX_DISPLAY_ITEMS)
-            : MAX_DISPLAY_ITEMS;
-    }, [maxItems]);
-    // Get files from directory - optimized for performance with depth limit
-    const loadFiles = useCallback(async () => {
-        const MAX_DEPTH = 5; // Limit recursion depth to prevent performance issues
-        const MAX_FILES = 1000; // Reduced from 2000 for better performance
-        const getFilesRecursively = async (dir, depth = 0) => {
-            // Stop recursion if depth limit reached
-            if (depth > MAX_DEPTH) {
-                return [];
-            }
-            try {
-                const entries = await fs.promises.readdir(dir, {
-                    withFileTypes: true,
-                });
-                let result = [];
-                // Common ignore patterns for better performance
-                const ignorePatterns = [
-                    'node_modules',
-                    'dist',
-                    'build',
-                    'coverage',
-                    '.git',
-                    '.vscode',
-                    '.idea',
-                    'out',
-                    'target',
-                    'bin',
-                    'obj',
-                    '.next',
-                    '.nuxt',
-                    'vendor',
-                    '__pycache__',
-                    '.pytest_cache',
-                    '.mypy_cache',
-                    'venv',
-                    '.venv',
-                    'env',
-                    '.env',
-                ];
-                for (const entry of entries) {
-                    // Early exit if we've collected enough files
-                    if (result.length >= MAX_FILES) {
-                        break;
-                    }
-                    // Skip hidden files and ignore patterns
-                    if (entry.name.startsWith('.') ||
-                        ignorePatterns.includes(entry.name)) {
-                        continue;
-                    }
-                    const fullPath = path.join(dir, entry.name);
-                    // Skip if file is too large (> 10MB) for performance
-                    try {
-                        const stats = await fs.promises.stat(fullPath);
-                        if (!entry.isDirectory() && stats.size > 10 * 1024 * 1024) {
-                            continue;
-                        }
-                    }
-                    catch {
-                        continue;
-                    }
-                    let relativePath = path.relative(rootPath, fullPath);
-                    // Ensure relative paths start with ./ for consistency
-                    if (!relativePath.startsWith('.') &&
-                        !path.isAbsolute(relativePath)) {
-                        relativePath = './' + relativePath;
-                    }
-                    // Normalize to forward slashes for cross-platform consistency
-                    relativePath = relativePath.replace(/\\/g, '/');
-                    result.push({
-                        name: entry.name,
-                        path: relativePath,
-                        isDirectory: entry.isDirectory(),
-                    });
-                    // Recursively get files from subdirectories with depth limit
-                    if (entry.isDirectory() && depth < MAX_DEPTH) {
-                        const subFiles = await getFilesRecursively(fullPath, depth + 1);
-                        result = result.concat(subFiles);
-                    }
-                }
-                return result;
-            }
-            catch (error) {
-                return [];
-            }
-        };
-        // Batch all state updates together
-        setIsLoading(true);
-        const fileList = await getFilesRecursively(rootPath);
-        setFiles(fileList);
-        setIsLoading(false);
-    }, [rootPath]);
-    // Search file content for content search mode
-    const searchFileContent = useCallback(async (query) => {
-        if (!query.trim()) {
-            return [];
-        }
-        const results = [];
-        const queryLower = query.toLowerCase();
-        const maxResults = 100; // Limit results for performance
-        // Text file extensions to search
-        const textExtensions = new Set([
-            '.js',
-            '.jsx',
-            '.ts',
-            '.tsx',
-            '.py',
-            '.java',
-            '.c',
-            '.cpp',
-            '.h',
-            '.hpp',
-            '.cs',
-            '.go',
-            '.rs',
-            '.rb',
-            '.php',
-            '.swift',
-            '.kt',
-            '.scala',
-            '.sh',
-            '.bash',
-            '.zsh',
-            '.fish',
-            '.ps1',
-            '.html',
-            '.css',
-            '.scss',
-            '.sass',
-            '.less',
-            '.xml',
-            '.json',
-            '.yaml',
-            '.yml',
-            '.toml',
-            '.ini',
-            '.conf',
-            '.config',
-            '.txt',
-            '.md',
-            '.markdown',
-            '.rst',
-            '.tex',
-            '.sql',
-            '.graphql',
-            '.proto',
-            '.vue',
-            '.svelte',
-        ]);
-        // Filter to only text files
-        const filesToSearch = files.filter(f => {
-            if (f.isDirectory)
-                return false;
-            const ext = path.extname(f.path).toLowerCase();
-            return textExtensions.has(ext);
-        });
-        // Process files in batches to avoid blocking
-        const batchSize = 10;
-        for (let batchStart = 0; batchStart < filesToSearch.length; batchStart += batchSize) {
-            if (results.length >= maxResults) {
-                break;
-            }
-            const batch = filesToSearch.slice(batchStart, batchStart + batchSize);
-            // Process batch files concurrently but with limit
-            const batchPromises = batch.map(async (file) => {
-                const fileResults = [];
-                try {
-                    const fullPath = path.join(rootPath, file.path);
-                    const content = await fs.promises.readFile(fullPath, 'utf-8');
-                    const lines = content.split('\n');
-                    // Search each line for the query
-                    for (let i = 0; i < lines.length; i++) {
-                        if (fileResults.length >= 10) {
-                            // Max 10 results per file
-                            break;
-                        }
-                        const line = lines[i];
-                        if (line && line.toLowerCase().includes(queryLower)) {
-                            const maxLineLength = Math.max(40, terminalWidth - 10);
-                            fileResults.push({
-                                name: file.name,
-                                path: file.path,
-                                isDirectory: false,
-                                lineNumber: i + 1,
-                                lineContent: line.trim().slice(0, maxLineLength),
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    // Skip files that can't be read (binary or encoding issues)
-                }
-                return fileResults;
-            });
-            // Wait for batch to complete
-            const batchResults = await Promise.all(batchPromises);
-            // Flatten and add to results
-            for (const fileResults of batchResults) {
-                if (results.length >= maxResults) {
-                    break;
-                }
-                results.push(...fileResults.slice(0, maxResults - results.length));
-            }
-        }
-        return results;
-    }, [files, rootPath, terminalWidth]);
-    // Load files when component becomes visible
-    // This ensures the file list is always fresh without complex file watching
-    useEffect(() => {
-        if (!visible) {
-            return;
-        }
-        // Always reload when becoming visible to ensure fresh data
-        loadFiles();
-    }, [visible, rootPath, loadFiles]);
-    // State for filtered files (needed for async content search)
-    const [allFilteredFiles, setAllFilteredFiles] = useState([]);
-    // Filter files based on query and search mode with debounce
-    useEffect(() => {
-        const performSearch = async () => {
-            if (!query.trim()) {
-                setAllFilteredFiles(files);
-                return;
-            }
-            if (searchMode === 'content') {
-                // Content search mode (@@)
-                const results = await searchFileContent(query);
-                setAllFilteredFiles(results);
-            }
-            else {
-                // File name search mode (@)
-                const queryLower = query.toLowerCase();
-                const filtered = files.filter(file => {
-                    const fileName = file.name.toLowerCase();
-                    const filePath = file.path.toLowerCase();
-                    return (fileName.includes(queryLower) || filePath.includes(queryLower));
-                });
-                // Sort by relevance (exact name matches first, then path matches)
-                filtered.sort((a, b) => {
-                    const aNameMatch = a.name.toLowerCase().startsWith(queryLower);
-                    const bNameMatch = b.name.toLowerCase().startsWith(queryLower);
-                    if (aNameMatch && !bNameMatch)
-                        return -1;
-                    if (!aNameMatch && bNameMatch)
-                        return 1;
-                    return a.name.localeCompare(b.name);
-                });
-                setAllFilteredFiles(filtered);
-            }
-        };
-        // Debounce search to avoid excessive updates during fast typing
-        // Use shorter delay for file search (150ms) and longer for content search (500ms)
-        const debounceDelay = searchMode === 'content' ? 500 : 150;
-        const timer = setTimeout(() => {
-            performSearch();
-        }, debounceDelay);
-        return () => clearTimeout(timer);
-    }, [files, query, searchMode, searchFileContent]);
-    // Display with scrolling window
-    const filteredFiles = useMemo(() => {
-        if (allFilteredFiles.length <= effectiveMaxItems) {
-            return allFilteredFiles;
-        }
-        // Show files around the selected index
-        const halfWindow = Math.floor(effectiveMaxItems / 2);
-        let startIndex = Math.max(0, selectedIndex - halfWindow);
-        let endIndex = Math.min(allFilteredFiles.length, startIndex + effectiveMaxItems);
-        // Adjust if we're near the end
-        if (endIndex - startIndex < effectiveMaxItems) {
-            startIndex = Math.max(0, endIndex - effectiveMaxItems);
-        }
-        return allFilteredFiles.slice(startIndex, endIndex);
-    }, [allFilteredFiles, selectedIndex, effectiveMaxItems]);
-    // Notify parent of filtered count changes
-    useEffect(() => {
-        if (onFilteredCountChange) {
-            onFilteredCountChange(allFilteredFiles.length);
-        }
-    }, [allFilteredFiles.length, onFilteredCountChange]);
-    // Expose methods to parent
-    useImperativeHandle(ref, () => ({
-        getSelectedFile: () => {
-            if (allFilteredFiles.length > 0 &&
-                selectedIndex < allFilteredFiles.length &&
-                allFilteredFiles[selectedIndex]) {
-                const selectedFile = allFilteredFiles[selectedIndex];
-                // For content search mode, include line number
-                if (selectedFile.lineNumber !== undefined) {
-                    return `${selectedFile.path}:${selectedFile.lineNumber}`;
-                }
-                return selectedFile.path;
-            }
-            return null;
-        },
-    }), [allFilteredFiles, selectedIndex]);
-    // Calculate display index for the scrolling window
-    // MUST be before early returns to avoid hook order issues
-    const displaySelectedIndex = useMemo(() => {
-        return filteredFiles.findIndex(file => {
-            const originalIndex = allFilteredFiles.indexOf(file);
-            return originalIndex === selectedIndex;
-        });
-    }, [filteredFiles, allFilteredFiles, selectedIndex]);
-    if (!visible) {
-        return null;
-    }
-    if (isLoading) {
-        return (React.createElement(Box, { paddingX: 1, marginTop: 1 },
-            React.createElement(Text, { color: "blue", dimColor: true }, "Loading files...")));
-    }
-    if (filteredFiles.length === 0) {
-        return (React.createElement(Box, { paddingX: 1, marginTop: 1 },
-            React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true }, "No files found")));
-    }
-    return (React.createElement(Box, { paddingX: 1, marginTop: 1, flexDirection: "column" },
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { color: "blue", bold: true },
-                searchMode === 'content' ? '≡ Content Search' : '≡ Files',
-                ' ',
-                allFilteredFiles.length > effectiveMaxItems &&
-                    `(${selectedIndex + 1}/${allFilteredFiles.length})`)),
-        filteredFiles.map((file, index) => (React.createElement(Box, { key: `${file.path}-${file.lineNumber || 0}`, flexDirection: "column" },
-            React.createElement(Text, { backgroundColor: index === displaySelectedIndex ? theme.colors.menuSelected : undefined, color: index === displaySelectedIndex
-                    ? theme.colors.menuNormal
-                    : file.isDirectory
-                        ? theme.colors.warning
-                        : 'white' }, searchMode === 'content' && file.lineNumber !== undefined
-                ? `${file.path}:${file.lineNumber}`
-                : file.isDirectory
-                    ? '◇ ' + file.path
-                    : '◆ ' + file.path),
-            searchMode === 'content' && file.lineContent && (React.createElement(Text, { backgroundColor: index === displaySelectedIndex ? theme.colors.menuSelected : undefined, color: index === displaySelectedIndex ? theme.colors.menuSecondary : theme.colors.menuSecondary, dimColor: true },
-                '  ',
-                file.lineContent))))),
-        allFilteredFiles.length > effectiveMaxItems && (React.createElement(Box, { marginTop: 1 },
-            React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true },
-                "\u2191\u2193 to scroll \u00B7 ",
-                allFilteredFiles.length - effectiveMaxItems,
-                ' ',
-                "more hidden")))));
-}));
-FileList.displayName = 'FileList';
-export default FileList;

package/dist/ui/components/FileRollbackConfirmation.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-type Props = {
-    fileCount: number;
-    filePaths: string[];
-    onConfirm: (rollbackFiles: boolean | null) => void;
-};
-export default function FileRollbackConfirmation({ fileCount, filePaths, onConfirm }: Props): React.JSX.Element;
-export {};

package/dist/ui/components/FileRollbackConfirmation.js

@@ -1,108 +0,0 @@
-import React, { useState } from 'react';
-import { Box, Text, useInput } from 'ink';
-export default function FileRollbackConfirmation({ fileCount, filePaths, onConfirm }) {
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    const [showFullList, setShowFullList] = useState(false);
-    const [fileScrollIndex, setFileScrollIndex] = useState(0);
-    const options = [
-        { label: 'Yes, rollback files and conversation', value: true },
-        { label: 'No, rollback conversation only', value: false }
-    ];
-    useInput((_, key) => {
-        // Tab - toggle full file list view
-        if (key.tab) {
-            setShowFullList(prev => !prev);
-            setFileScrollIndex(0); // Reset scroll when toggling
-            return;
-        }
-        // In full list mode, use up/down to scroll files
-        if (showFullList) {
-            const maxVisibleFiles = 10;
-            const maxScroll = Math.max(0, filePaths.length - maxVisibleFiles);
-            if (key.upArrow) {
-                setFileScrollIndex(prev => Math.max(0, prev - 1));
-                return;
-            }
-            if (key.downArrow) {
-                setFileScrollIndex(prev => Math.min(maxScroll, prev + 1));
-                return;
-            }
-        }
-        else {
-            // In compact mode, up/down navigate options
-            if (key.upArrow) {
-                setSelectedIndex(prev => Math.max(0, prev - 1));
-                return;
-            }
-            if (key.downArrow) {
-                setSelectedIndex(prev => Math.min(options.length - 1, prev + 1));
-                return;
-            }
-        }
-        // Enter - confirm selection (only when not in full list mode)
-        if (key.return && !showFullList) {
-            onConfirm(options[selectedIndex]?.value ?? false);
-            return;
-        }
-        // ESC - exit full list mode or cancel rollback
-        if (key.escape) {
-            if (showFullList) {
-                setShowFullList(false);
-                setFileScrollIndex(0);
-            }
-            else {
-                onConfirm(null); // null means cancel everything
-            }
-            return;
-        }
-    });
-    // Display logic for file list
-    const maxFilesToShowCompact = 5;
-    const maxFilesToShowFull = 10;
-    const displayFiles = showFullList
-        ? filePaths.slice(fileScrollIndex, fileScrollIndex + maxFilesToShowFull)
-        : filePaths.slice(0, maxFilesToShowCompact);
-    const remainingCountCompact = fileCount - maxFilesToShowCompact;
-    const hasMoreAbove = showFullList && fileScrollIndex > 0;
-    const hasMoreBelow = showFullList && (fileScrollIndex + maxFilesToShowFull) < filePaths.length;
-    return (React.createElement(Box, { flexDirection: "column", marginX: 1, marginBottom: 1, padding: 1 },
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { color: "yellow", bold: true }, "\u26A0  File Rollback Confirmation")),
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { color: "white" },
-                "This checkpoint has ",
-                fileCount,
-                " file",
-                fileCount > 1 ? 's' : '',
-                " that will be rolled back:")),
-        React.createElement(Box, { flexDirection: "column", marginBottom: 1, marginLeft: 2 },
-            hasMoreAbove && (React.createElement(Text, { color: "gray", dimColor: true },
-                "\u2191 ",
-                fileScrollIndex,
-                " more above...")),
-            displayFiles.map((file, index) => (React.createElement(Text, { key: index, color: "cyan", dimColor: true },
-                "\u2022 ",
-                file))),
-            hasMoreBelow && (React.createElement(Text, { color: "gray", dimColor: true },
-                "\u2193 ",
-                filePaths.length - (fileScrollIndex + maxFilesToShowFull),
-                " more below...")),
-            !showFullList && remainingCountCompact > 0 && (React.createElement(Text, { color: "gray", dimColor: true },
-                "... and ",
-                remainingCountCompact,
-                " more file",
-                remainingCountCompact > 1 ? 's' : ''))),
-        !showFullList && (React.createElement(React.Fragment, null,
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, { color: "gray", dimColor: true }, "Do you want to rollback the files as well?")),
-            React.createElement(Box, { flexDirection: "column", marginBottom: 1 }, options.map((option, index) => (React.createElement(Box, { key: index },
-                React.createElement(Text, { color: index === selectedIndex ? 'green' : 'white', bold: index === selectedIndex },
-                    index === selectedIndex ? '❯  ' : '  ',
-                    option.label))))))),
-        React.createElement(Box, null,
-            React.createElement(Text, { color: "gray", dimColor: true }, showFullList
-                ? '↑↓ scroll · Tab back · ESC close'
-                : fileCount > maxFilesToShowCompact
-                    ? `↑↓ select · Tab view all (${fileCount} files) · Enter confirm · ESC cancel`
-                    : '↑↓ select · Enter confirm · ESC cancel'))));
-}

package/dist/ui/components/HelpPanel.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export default function HelpPanel(): React.JSX.Element;