snow-ai 0.2.15 → 0.2.16

package/dist/hooks/useKeyboardInput.js

@@ -0,0 +1,272 @@
+import { useRef, useEffect } from 'react';
+import { useInput } from 'ink';
+import { executeCommand } from '../utils/commandExecutor.js';
+export function useKeyboardInput(options) {
+    const { buffer, disabled, triggerUpdate, forceUpdate, showCommands, setShowCommands, commandSelectedIndex, setCommandSelectedIndex, getFilteredCommands, updateCommandPanelState, onCommand, showFilePicker, setShowFilePicker, fileSelectedIndex, setFileSelectedIndex, setFileQuery, setAtSymbolPosition, filteredFileCount, updateFilePickerState, handleFileSelect, fileListRef, showHistoryMenu, setShowHistoryMenu, historySelectedIndex, setHistorySelectedIndex, escapeKeyCount, setEscapeKeyCount, escapeKeyTimer, getUserMessages, handleHistorySelect, pasteFromClipboard, onSubmit, } = options;
+    // Track paste detection
+    const inputBuffer = useRef('');
+    const inputTimer = useRef(null);
+    // Cleanup timer on unmount
+    useEffect(() => {
+        return () => {
+            if (inputTimer.current) {
+                clearTimeout(inputTimer.current);
+            }
+        };
+    }, []);
+    // Force immediate state update for critical operations like backspace
+    const forceStateUpdate = () => {
+        const text = buffer.getFullText();
+        const cursorPos = buffer.getCursorPosition();
+        updateFilePickerState(text, cursorPos);
+        updateCommandPanelState(text);
+        forceUpdate({});
+    };
+    // Handle input using useInput hook
+    useInput((input, key) => {
+        if (disabled)
+            return;
+        // Handle escape key for double-ESC history navigation
+        if (key.escape) {
+            // Close file picker if open
+            if (showFilePicker) {
+                setShowFilePicker(false);
+                setFileSelectedIndex(0);
+                setFileQuery('');
+                setAtSymbolPosition(-1);
+                return;
+            }
+            // Don't interfere with existing ESC behavior if in command panel
+            if (showCommands) {
+                setShowCommands(false);
+                setCommandSelectedIndex(0);
+                return;
+            }
+            // Handle history navigation
+            if (showHistoryMenu) {
+                setShowHistoryMenu(false);
+                return;
+            }
+            // Count escape key presses for double-ESC detection
+            setEscapeKeyCount(prev => prev + 1);
+            // Clear any existing timer
+            if (escapeKeyTimer.current) {
+                clearTimeout(escapeKeyTimer.current);
+            }
+            // Set timer to reset count after 500ms
+            escapeKeyTimer.current = setTimeout(() => {
+                setEscapeKeyCount(0);
+            }, 500);
+            // Check for double escape
+            if (escapeKeyCount >= 1) {
+                // This will be 2 after increment
+                const userMessages = getUserMessages();
+                if (userMessages.length > 0) {
+                    setShowHistoryMenu(true);
+                    setHistorySelectedIndex(0); // Reset selection to first item
+                    setEscapeKeyCount(0);
+                    if (escapeKeyTimer.current) {
+                        clearTimeout(escapeKeyTimer.current);
+                        escapeKeyTimer.current = null;
+                    }
+                }
+            }
+            return;
+        }
+        // Handle history menu navigation
+        if (showHistoryMenu) {
+            const userMessages = getUserMessages();
+            // Up arrow in history menu
+            if (key.upArrow) {
+                setHistorySelectedIndex(prev => Math.max(0, prev - 1));
+                return;
+            }
+            // Down arrow in history menu
+            if (key.downArrow) {
+                const maxIndex = Math.max(0, userMessages.length - 1);
+                setHistorySelectedIndex(prev => Math.min(maxIndex, prev + 1));
+                return;
+            }
+            // Enter - select history item
+            if (key.return) {
+                if (userMessages.length > 0 &&
+                    historySelectedIndex < userMessages.length) {
+                    const selectedMessage = userMessages[historySelectedIndex];
+                    if (selectedMessage) {
+                        handleHistorySelect(selectedMessage.value);
+                    }
+                }
+                return;
+            }
+            // For any other key in history menu, just return to prevent interference
+            return;
+        }
+        // Ctrl+L - Delete from cursor to beginning
+        if (key.ctrl && input === 'l') {
+            const fullText = buffer.getFullText();
+            const cursorPos = buffer.getCursorPosition();
+            const afterCursor = fullText.slice(cursorPos);
+            buffer.setText(afterCursor);
+            forceStateUpdate();
+            return;
+        }
+        // Ctrl+R - Delete from cursor to end
+        if (key.ctrl && input === 'r') {
+            const fullText = buffer.getFullText();
+            const cursorPos = buffer.getCursorPosition();
+            const beforeCursor = fullText.slice(0, cursorPos);
+            buffer.setText(beforeCursor);
+            forceStateUpdate();
+            return;
+        }
+        // Windows: Alt+V, macOS: Ctrl+V - Paste from clipboard (including images)
+        const isPasteShortcut = process.platform === 'darwin'
+            ? key.ctrl && input === 'v'
+            : key.meta && input === 'v';
+        if (isPasteShortcut) {
+            pasteFromClipboard();
+            return;
+        }
+        // Backspace
+        if (key.backspace || key.delete) {
+            buffer.backspace();
+            forceStateUpdate();
+            return;
+        }
+        // Handle file picker navigation
+        if (showFilePicker) {
+            // Up arrow in file picker
+            if (key.upArrow) {
+                setFileSelectedIndex(prev => Math.max(0, prev - 1));
+                return;
+            }
+            // Down arrow in file picker
+            if (key.downArrow) {
+                const maxIndex = Math.max(0, filteredFileCount - 1);
+                setFileSelectedIndex(prev => Math.min(maxIndex, prev + 1));
+                return;
+            }
+            // Tab or Enter - select file
+            if (key.tab || key.return) {
+                if (filteredFileCount > 0 && fileSelectedIndex < filteredFileCount) {
+                    const selectedFile = fileListRef.current?.getSelectedFile();
+                    if (selectedFile) {
+                        handleFileSelect(selectedFile);
+                    }
+                }
+                return;
+            }
+        }
+        // Handle command panel navigation
+        if (showCommands) {
+            const filteredCommands = getFilteredCommands();
+            // Up arrow in command panel
+            if (key.upArrow) {
+                setCommandSelectedIndex(prev => Math.max(0, prev - 1));
+                return;
+            }
+            // Down arrow in command panel
+            if (key.downArrow) {
+                const maxIndex = Math.max(0, filteredCommands.length - 1);
+                setCommandSelectedIndex(prev => Math.min(maxIndex, prev + 1));
+                return;
+            }
+            // Enter - select command
+            if (key.return) {
+                if (filteredCommands.length > 0 &&
+                    commandSelectedIndex < filteredCommands.length) {
+                    const selectedCommand = filteredCommands[commandSelectedIndex];
+                    if (selectedCommand) {
+                        // Execute command instead of inserting text
+                        executeCommand(selectedCommand.name).then(result => {
+                            if (onCommand) {
+                                onCommand(selectedCommand.name, result);
+                            }
+                        });
+                        buffer.setText('');
+                        setShowCommands(false);
+                        setCommandSelectedIndex(0);
+                        triggerUpdate();
+                        return;
+                    }
+                }
+                // If no commands available, fall through to normal Enter handling
+            }
+        }
+        // Enter - submit message
+        if (key.return) {
+            const message = buffer.getFullText().trim();
+            if (message) {
+                // Get images data, but only include images whose placeholders still exist
+                const currentText = buffer.text; // Use internal text (includes placeholders)
+                const allImages = buffer.getImages();
+                const validImages = allImages
+                    .filter(img => currentText.includes(img.placeholder))
+                    .map(img => ({
+                    data: img.data,
+                    mimeType: img.mimeType,
+                }));
+                buffer.setText('');
+                forceUpdate({});
+                onSubmit(message, validImages.length > 0 ? validImages : undefined);
+            }
+            return;
+        }
+        // Arrow keys for cursor movement
+        if (key.leftArrow) {
+            buffer.moveLeft();
+            const text = buffer.getFullText();
+            const cursorPos = buffer.getCursorPosition();
+            updateFilePickerState(text, cursorPos);
+            triggerUpdate();
+            return;
+        }
+        if (key.rightArrow) {
+            buffer.moveRight();
+            const text = buffer.getFullText();
+            const cursorPos = buffer.getCursorPosition();
+            updateFilePickerState(text, cursorPos);
+            triggerUpdate();
+            return;
+        }
+        if (key.upArrow && !showCommands && !showFilePicker) {
+            buffer.moveUp();
+            const text = buffer.getFullText();
+            const cursorPos = buffer.getCursorPosition();
+            updateFilePickerState(text, cursorPos);
+            triggerUpdate();
+            return;
+        }
+        if (key.downArrow && !showCommands && !showFilePicker) {
+            buffer.moveDown();
+            const text = buffer.getFullText();
+            const cursorPos = buffer.getCursorPosition();
+            updateFilePickerState(text, cursorPos);
+            triggerUpdate();
+            return;
+        }
+        // Regular character input
+        if (input && !key.ctrl && !key.meta && !key.escape) {
+            // Accumulate input for paste detection
+            inputBuffer.current += input;
+            // Clear existing timer
+            if (inputTimer.current) {
+                clearTimeout(inputTimer.current);
+            }
+            // Set timer to process accumulated input
+            inputTimer.current = setTimeout(() => {
+                const accumulated = inputBuffer.current;
+                inputBuffer.current = '';
+                // If we accumulated input, it's likely a paste
+                if (accumulated) {
+                    buffer.insert(accumulated);
+                    const text = buffer.getFullText();
+                    const cursorPos = buffer.getCursorPosition();
+                    updateCommandPanelState(text);
+                    updateFilePickerState(text, cursorPos);
+                    triggerUpdate();
+                }
+            }, 10); // Short delay to accumulate rapid input
+        }
+    });
+}

package/dist/hooks/useSnapshotState.d.ts

@@ -0,0 +1,12 @@
+export declare function useSnapshotState(messagesLength: number): {
+    snapshotFileCount: Map<number, number>;
+    setSnapshotFileCount: import("react").Dispatch<import("react").SetStateAction<Map<number, number>>>;
+    pendingRollback: {
+        messageIndex: number;
+        fileCount: number;
+    } | null;
+    setPendingRollback: import("react").Dispatch<import("react").SetStateAction<{
+        messageIndex: number;
+        fileCount: number;
+    } | null>>;
+};

package/dist/hooks/useSnapshotState.js

@@ -0,0 +1,28 @@
+import { useState, useEffect } from 'react';
+import { sessionManager } from '../utils/sessionManager.js';
+import { incrementalSnapshotManager } from '../utils/incrementalSnapshot.js';
+export function useSnapshotState(messagesLength) {
+    const [snapshotFileCount, setSnapshotFileCount] = useState(new Map());
+    const [pendingRollback, setPendingRollback] = useState(null);
+    // Load snapshot file counts when session changes
+    useEffect(() => {
+        const loadSnapshotFileCounts = async () => {
+            const currentSession = sessionManager.getCurrentSession();
+            if (!currentSession)
+                return;
+            const snapshots = await incrementalSnapshotManager.listSnapshots(currentSession.id);
+            const counts = new Map();
+            for (const snapshot of snapshots) {
+                counts.set(snapshot.messageIndex, snapshot.fileCount);
+            }
+            setSnapshotFileCount(counts);
+        };
+        loadSnapshotFileCounts();
+    }, [messagesLength]); // Reload when messages change
+    return {
+        snapshotFileCount,
+        setSnapshotFileCount,
+        pendingRollback,
+        setPendingRollback,
+    };
+}

package/dist/hooks/useStreamingState.d.ts

@@ -0,0 +1,24 @@
+import type { UsageInfo } from '../api/chat.js';
+export type RetryStatus = {
+    isRetrying: boolean;
+    attempt: number;
+    nextDelay: number;
+    remainingSeconds?: number;
+    errorMessage?: string;
+};
+export declare function useStreamingState(): {
+    isStreaming: boolean;
+    setIsStreaming: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    streamTokenCount: number;
+    setStreamTokenCount: import("react").Dispatch<import("react").SetStateAction<number>>;
+    isReasoning: boolean;
+    setIsReasoning: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    abortController: AbortController | null;
+    setAbortController: import("react").Dispatch<import("react").SetStateAction<AbortController | null>>;
+    contextUsage: UsageInfo | null;
+    setContextUsage: import("react").Dispatch<import("react").SetStateAction<UsageInfo | null>>;
+    elapsedSeconds: number;
+    retryStatus: RetryStatus | null;
+    setRetryStatus: import("react").Dispatch<import("react").SetStateAction<RetryStatus | null>>;
+    animationFrame: number;
+};

package/dist/hooks/useStreamingState.js

@@ -0,0 +1,96 @@
+import { useState, useEffect } from 'react';
+export function useStreamingState() {
+    const [isStreaming, setIsStreaming] = useState(false);
+    const [streamTokenCount, setStreamTokenCount] = useState(0);
+    const [isReasoning, setIsReasoning] = useState(false);
+    const [abortController, setAbortController] = useState(null);
+    const [contextUsage, setContextUsage] = useState(null);
+    const [elapsedSeconds, setElapsedSeconds] = useState(0);
+    const [timerStartTime, setTimerStartTime] = useState(null);
+    const [retryStatus, setRetryStatus] = useState(null);
+    const [animationFrame, setAnimationFrame] = useState(0);
+    // Animation for streaming/saving indicator
+    useEffect(() => {
+        if (!isStreaming)
+            return;
+        const interval = setInterval(() => {
+            setAnimationFrame(prev => (prev + 1) % 5);
+        }, 300);
+        return () => {
+            clearInterval(interval);
+            setAnimationFrame(0);
+        };
+    }, [isStreaming]);
+    // Timer for tracking request duration
+    useEffect(() => {
+        if (isStreaming && timerStartTime === null) {
+            // Start timer when streaming begins
+            setTimerStartTime(Date.now());
+            setElapsedSeconds(0);
+        }
+        else if (!isStreaming && timerStartTime !== null) {
+            // Stop timer when streaming ends
+            setTimerStartTime(null);
+        }
+    }, [isStreaming, timerStartTime]);
+    // Update elapsed time every second
+    useEffect(() => {
+        if (timerStartTime === null)
+            return;
+        const interval = setInterval(() => {
+            const elapsed = Math.floor((Date.now() - timerStartTime) / 1000);
+            setElapsedSeconds(elapsed);
+        }, 1000);
+        return () => clearInterval(interval);
+    }, [timerStartTime]);
+    // Countdown timer for retry delays
+    useEffect(() => {
+        if (!retryStatus || !retryStatus.isRetrying)
+            return;
+        // Initialize remaining seconds from nextDelay
+        if (retryStatus.remainingSeconds === undefined) {
+            setRetryStatus(prev => prev
+                ? {
+                    ...prev,
+                    remainingSeconds: Math.ceil(prev.nextDelay / 1000),
+                }
+                : null);
+            return;
+        }
+        // Countdown every second
+        const interval = setInterval(() => {
+            setRetryStatus(prev => {
+                if (!prev || prev.remainingSeconds === undefined)
+                    return prev;
+                const newRemaining = prev.remainingSeconds - 1;
+                if (newRemaining <= 0) {
+                    return {
+                        ...prev,
+                        remainingSeconds: 0,
+                    };
+                }
+                return {
+                    ...prev,
+                    remainingSeconds: newRemaining,
+                };
+            });
+        }, 1000);
+        return () => clearInterval(interval);
+    }, [retryStatus]);
+    return {
+        isStreaming,
+        setIsStreaming,
+        streamTokenCount,
+        setStreamTokenCount,
+        isReasoning,
+        setIsReasoning,
+        abortController,
+        setAbortController,
+        contextUsage,
+        setContextUsage,
+        elapsedSeconds,
+        retryStatus,
+        setRetryStatus,
+        animationFrame,
+    };
+}

package/dist/hooks/useVSCodeState.d.ts

@@ -0,0 +1,8 @@
+import { type EditorContext } from '../utils/vscodeConnection.js';
+export type VSCodeConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+export declare function useVSCodeState(): {
+    vscodeConnected: boolean;
+    vscodeConnectionStatus: VSCodeConnectionStatus;
+    setVscodeConnectionStatus: import("react").Dispatch<import("react").SetStateAction<VSCodeConnectionStatus>>;
+    editorContext: EditorContext;
+};

package/dist/hooks/useVSCodeState.js

@@ -0,0 +1,63 @@
+import { useState, useEffect } from 'react';
+import { vscodeConnection } from '../utils/vscodeConnection.js';
+export function useVSCodeState() {
+    const [vscodeConnected, setVscodeConnected] = useState(false);
+    const [vscodeConnectionStatus, setVscodeConnectionStatus] = useState('disconnected');
+    const [editorContext, setEditorContext] = useState({});
+    // Monitor VSCode connection status and editor context
+    useEffect(() => {
+        const checkConnectionInterval = setInterval(() => {
+            const isConnected = vscodeConnection.isConnected();
+            setVscodeConnected(isConnected);
+            // Update connection status based on actual connection state
+            if (isConnected && vscodeConnectionStatus !== 'connected') {
+                setVscodeConnectionStatus('connected');
+            }
+            else if (!isConnected && vscodeConnectionStatus === 'connected') {
+                setVscodeConnectionStatus('disconnected');
+            }
+        }, 1000);
+        const unsubscribe = vscodeConnection.onContextUpdate(context => {
+            setEditorContext(context);
+            // When we receive context, it means connection is successful
+            if (vscodeConnectionStatus !== 'connected') {
+                setVscodeConnectionStatus('connected');
+            }
+        });
+        return () => {
+            clearInterval(checkConnectionInterval);
+            unsubscribe();
+        };
+    }, [vscodeConnectionStatus]);
+    // Separate effect for handling connecting timeout
+    useEffect(() => {
+        if (vscodeConnectionStatus !== 'connecting') {
+            return;
+        }
+        // Set timeout for connecting state (30 seconds to allow for VSCode extension reconnection)
+        const connectingTimeout = setTimeout(() => {
+            const isConnected = vscodeConnection.isConnected();
+            const isServerRunning = vscodeConnection.isServerRunning();
+            // Only set error if still not connected after timeout
+            if (!isConnected) {
+                if (isServerRunning) {
+                    // Server is running but no connection - show error with helpful message
+                    setVscodeConnectionStatus('error');
+                }
+                else {
+                    // Server not running - go back to disconnected
+                    setVscodeConnectionStatus('disconnected');
+                }
+            }
+        }, 30000); // Increased to 30 seconds
+        return () => {
+            clearTimeout(connectingTimeout);
+        };
+    }, [vscodeConnectionStatus]);
+    return {
+        vscodeConnected,
+        vscodeConnectionStatus,
+        setVscodeConnectionStatus,
+        editorContext,
+    };
+}

package/dist/mcp/filesystem.d.ts

@@ -82,12 +82,12 @@ export declare class FilesystemMCPService {
      */
     createFile(filePath: string, content: string, createDirectories?: boolean): Promise<string>;
     /**
-     * Delete a file
-     * @param filePath - Path to the file to delete
-     * @returns Success message
+     * Delete one or multiple files
+     * @param filePaths - Single file path or array of file paths to delete
+     * @returns Success message with details
      * @throws Error if file deletion fails
      */
-    deleteFile(filePath: string): Promise<string>;
+    deleteFile(filePaths: string | string[]): Promise<string>;
     /**
      * List files in a directory
      * @param dirPath - Directory path relative to base path or absolute path
@@ -181,6 +181,7 @@ export declare const mcpTools: ({
             };
             content?: undefined;
             createDirectories?: undefined;
+            filePaths?: undefined;
             dirPath?: undefined;
             newContent?: undefined;
             contextLines?: undefined;
@@ -213,6 +214,7 @@ export declare const mcpTools: ({
             };
             startLine?: undefined;
             endLine?: undefined;
+            filePaths?: undefined;
             dirPath?: undefined;
             newContent?: undefined;
             contextLines?: undefined;
@@ -234,6 +236,20 @@ export declare const mcpTools: ({
                 type: string;
                 description: string;
             };
+            filePaths: {
+                oneOf: ({
+                    type: string;
+                    description: string;
+                    items?: undefined;
+                } | {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    description: string;
+                })[];
+                description: string;
+            };
             startLine?: undefined;
             endLine?: undefined;
             content?: undefined;
@@ -247,7 +263,7 @@ export declare const mcpTools: ({
             maxResults?: undefined;
             searchMode?: undefined;
         };
-        required: string[];
+        required?: undefined;
     };
 } | {
     name: string;
@@ -265,6 +281,7 @@ export declare const mcpTools: ({
             endLine?: undefined;
             content?: undefined;
             createDirectories?: undefined;
+            filePaths?: undefined;
             newContent?: undefined;
             contextLines?: undefined;
             query?: undefined;
@@ -304,6 +321,7 @@ export declare const mcpTools: ({
             };
             content?: undefined;
             createDirectories?: undefined;
+            filePaths?: undefined;
             dirPath?: undefined;
             query?: undefined;
             fileExtensions?: undefined;
@@ -357,6 +375,7 @@ export declare const mcpTools: ({
             endLine?: undefined;
             content?: undefined;
             createDirectories?: undefined;
+            filePaths?: undefined;
             newContent?: undefined;
             contextLines?: undefined;
         };