snow-ai 0.4.15 → 0.4.17

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;

package/dist/ui/components/HelpPanel.js

@@ -1,67 +0,0 @@
-import React from 'react';
-import { Box, Text } from 'ink';
-import { useI18n } from '../../i18n/index.js';
-// Get platform-specific paste key
-const getPasteKey = () => {
-    return process.platform === 'darwin' ? 'Ctrl+V' : 'Alt+V';
-};
-export default function HelpPanel() {
-    const pasteKey = getPasteKey();
-    const { t } = useI18n();
-    return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1 },
-        React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "cyan" }, t.helpPanel.title)),
-        React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "yellow" }, t.helpPanel.textEditingTitle),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.deleteToStart),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.deleteToEnd),
-            React.createElement(Text, null,
-                ' ',
-                "\u2022 ",
-                t.helpPanel.pasteImages.replace('{pasteKey}', pasteKey))),
-        React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "green" }, t.helpPanel.quickAccessTitle),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.insertFiles),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.searchContent),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.selectAgent),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.showCommands)),
-        React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "blue" }, t.helpPanel.navigationTitle),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.navigateHistory),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.selectItem),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.cancelClose),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.toggleYolo)),
-        React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Text, { bold: true, color: "magenta" }, t.helpPanel.tipsTitle),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.tipUseHelp),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.tipShowCommands),
-            React.createElement(Text, null,
-                " \u2022 ",
-                t.helpPanel.tipInterrupt)),
-        React.createElement(Box, { marginTop: 1 },
-            React.createElement(Text, { dimColor: true, color: "gray" }, t.helpPanel.closeHint))));
-}

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

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

package/dist/ui/components/MCPInfoPanel.js

@@ -1,108 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Box, Text } from 'ink';
-import SelectInput from 'ink-select-input';
-import { getMCPServicesInfo, refreshMCPToolsCache, reconnectMCPService } from '../../utils/mcpToolsManager.js';
-export default function MCPInfoPanel() {
-    const [mcpStatus, setMcpStatus] = useState([]);
-    const [isLoading, setIsLoading] = useState(true);
-    const [errorMessage, setErrorMessage] = useState(null);
-    const [isReconnecting, setIsReconnecting] = useState(false);
-    const loadMCPStatus = async () => {
-        try {
-            const servicesInfo = await getMCPServicesInfo();
-            const statusList = servicesInfo.map(service => ({
-                name: service.serviceName,
-                connected: service.connected,
-                tools: service.tools.map(tool => tool.name),
-                connectionMethod: service.isBuiltIn ? 'Built-in' : 'External',
-                isBuiltIn: service.isBuiltIn,
-                error: service.error
-            }));
-            setMcpStatus(statusList);
-            setErrorMessage(null);
-            setIsLoading(false);
-        }
-        catch (error) {
-            setErrorMessage(error instanceof Error ? error.message : 'Failed to load MCP services');
-            setIsLoading(false);
-        }
-    };
-    useEffect(() => {
-        let isMounted = true;
-        const load = async () => {
-            await loadMCPStatus();
-        };
-        if (isMounted) {
-            load();
-        }
-        return () => {
-            isMounted = false;
-        };
-    }, []);
-    const handleServiceSelect = async (item) => {
-        setIsReconnecting(true);
-        try {
-            if (item.value === 'refresh-all') {
-                // Refresh all services
-                await refreshMCPToolsCache();
-            }
-            else {
-                // Reconnect specific service
-                await reconnectMCPService(item.value);
-            }
-            await loadMCPStatus();
-        }
-        catch (error) {
-            setErrorMessage(error instanceof Error ? error.message : 'Failed to reconnect');
-        }
-        finally {
-            setIsReconnecting(false);
-        }
-    };
-    // Build select items from all services
-    const selectItems = [
-        { label: 'Refresh all services', value: 'refresh-all', isRefreshAll: true },
-        ...mcpStatus.map(s => ({
-            label: s.name,
-            value: s.name,
-            connected: s.connected,
-            isBuiltIn: s.isBuiltIn,
-            error: s.error
-        }))
-    ];
-    // Custom item component to render with colors
-    const ItemComponent = ({ isSelected, label }) => {
-        const item = selectItems.find(i => i.label === label);
-        if (!item)
-            return React.createElement(Text, null, label);
-        if (item.isRefreshAll) {
-            return (React.createElement(Text, { color: isSelected ? 'cyan' : 'blue' },
-                "\u21BB ",
-                label));
-        }
-        const statusColor = item.connected ? 'green' : 'red';
-        const suffix = item.isBuiltIn ? ' (System)' : item.connected ? ' (External)' : ` - ${item.error || 'Failed'}`;
-        return (React.createElement(Box, null,
-            React.createElement(Text, { color: statusColor }, "\u25CF "),
-            React.createElement(Text, { color: isSelected ? 'cyan' : 'white' }, label),
-            React.createElement(Text, { color: "gray", dimColor: true }, suffix)));
-    };
-    if (isLoading) {
-        return (React.createElement(Text, { color: "gray" }, "Loading MCP services..."));
-    }
-    if (errorMessage) {
-        return (React.createElement(Box, { borderColor: "red", borderStyle: "round", paddingX: 2, paddingY: 0 },
-            React.createElement(Text, { color: "red", dimColor: true },
-                "Error: ",
-                errorMessage)));
-    }
-    if (mcpStatus.length === 0) {
-        return (React.createElement(Box, { borderColor: "cyan", borderStyle: "round", paddingX: 2, paddingY: 0 },
-            React.createElement(Text, { color: "gray", dimColor: true }, "No available MCP services detected")));
-    }
-    return (React.createElement(Box, { borderColor: "cyan", borderStyle: "round", paddingX: 2, paddingY: 0 },
-        React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Text, { color: "cyan", bold: true }, isReconnecting ? 'Refreshing services...' : 'MCP Services'),
-            !isReconnecting && (React.createElement(SelectInput, { items: selectItems, onSelect: handleServiceSelect, itemComponent: ItemComponent })),
-            isReconnecting && (React.createElement(Text, { color: "yellow", dimColor: true }, "Please wait...")))));
-}