snow-ai 0.4.16 → 0.4.17

package/dist/hooks/useSessionSave.js

@@ -1,63 +0,0 @@
-import { useCallback, useRef } from 'react';
-import { sessionManager } from '../utils/sessionManager.js';
-export function useSessionSave() {
-    const savedMessagesRef = useRef(new Set());
-    // Generate a unique ID for a message (based on role + content + timestamp window + tool identifiers)
-    const generateMessageId = useCallback((message, timestamp) => {
-        // Base ID with role, content length, and time window
-        let id = `${message.role}-${message.content.length}-${Math.floor(timestamp / 5000)}`;
-        // For assistant messages with tool_calls, include tool call IDs to ensure uniqueness
-        if (message.role === 'assistant' && message.tool_calls && message.tool_calls.length > 0) {
-            const toolCallIds = message.tool_calls.map(tc => tc.id).sort().join(',');
-            id += `-tools:${toolCallIds}`;
-        }
-        // For tool result messages, include the tool_call_id to ensure uniqueness
-        if (message.role === 'tool' && message.tool_call_id) {
-            id += `-toolcall:${message.tool_call_id}`;
-        }
-        return id;
-    }, []);
-    // Save API message directly - 直接保存 API 格式的消息
-    const saveMessage = useCallback(async (message) => {
-        const timestamp = Date.now();
-        const messageId = generateMessageId(message, timestamp);
-        if (savedMessagesRef.current.has(messageId)) {
-            return; // Already saved
-        }
-        const sessionMessage = {
-            ...message, // 直接展开 API 消息，包含所有字段
-            timestamp
-        };
-        try {
-            await sessionManager.addMessage(sessionMessage);
-            savedMessagesRef.current.add(messageId);
-        }
-        catch (error) {
-            console.error('Failed to save message:', error);
-        }
-    }, [generateMessageId]);
-    // Save multiple API messages at once
-    const saveMessages = useCallback(async (messages) => {
-        for (const message of messages) {
-            await saveMessage(message);
-        }
-    }, [saveMessage]);
-    // Clear saved messages tracking (for new sessions)
-    const clearSavedMessages = useCallback(() => {
-        savedMessagesRef.current.clear();
-    }, []);
-    // Initialize from existing session - 从已有会话初始化
-    const initializeFromSession = useCallback((messages) => {
-        savedMessagesRef.current.clear();
-        messages.forEach(message => {
-            const messageId = generateMessageId(message, message.timestamp);
-            savedMessagesRef.current.add(messageId);
-        });
-    }, [generateMessageId]);
-    return {
-        saveMessage,
-        saveMessages,
-        clearSavedMessages,
-        initializeFromSession
-    };
-}

package/dist/hooks/useSnapshotState.d.ts

@@ -1,26 +0,0 @@
-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;
-        filePaths?: string[];
-        message?: string;
-        images?: Array<{
-            type: "image";
-            data: string;
-            mimeType: string;
-        }>;
-    } | null;
-    setPendingRollback: import("react").Dispatch<import("react").SetStateAction<{
-        messageIndex: number;
-        fileCount: number;
-        filePaths?: string[];
-        message?: string;
-        images?: Array<{
-            type: "image";
-            data: string;
-            mimeType: string;
-        }>;
-    } | null>>;
-};

package/dist/hooks/useSnapshotState.js

@@ -1,28 +0,0 @@
-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

@@ -1,33 +0,0 @@
-import type { UsageInfo } from '../api/chat.js';
-export type RetryStatus = {
-    isRetrying: boolean;
-    attempt: number;
-    nextDelay: number;
-    remainingSeconds?: number;
-    errorMessage?: string;
-};
-export type CodebaseSearchStatus = {
-    isSearching: boolean;
-    attempt: number;
-    maxAttempts: number;
-    currentTopN: number;
-    message: 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;
-    codebaseSearchStatus: CodebaseSearchStatus | null;
-    setCodebaseSearchStatus: import("react").Dispatch<import("react").SetStateAction<CodebaseSearchStatus | null>>;
-};

package/dist/hooks/useStreamingState.js

@@ -1,105 +0,0 @@
-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);
-    const [codebaseSearchStatus, setCodebaseSearchStatus] = useState(null);
-    // 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]);
-    // Initialize remaining seconds when retry starts
-    useEffect(() => {
-        if (!retryStatus?.isRetrying)
-            return;
-        if (retryStatus.remainingSeconds !== undefined)
-            return;
-        // Initialize remaining seconds from nextDelay (only once)
-        setRetryStatus(prev => prev
-            ? {
-                ...prev,
-                remainingSeconds: Math.ceil(prev.nextDelay / 1000),
-            }
-            : null);
-    }, [retryStatus?.isRetrying]); // Only depend on isRetrying flag
-    // Countdown timer for retry delays
-    useEffect(() => {
-        if (!retryStatus || !retryStatus.isRetrying)
-            return;
-        if (retryStatus.remainingSeconds === undefined)
-            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?.isRetrying]); // ✅ 移除 remainingSeconds 避免循环
-    return {
-        isStreaming,
-        setIsStreaming,
-        streamTokenCount,
-        setStreamTokenCount,
-        isReasoning,
-        setIsReasoning,
-        abortController,
-        setAbortController,
-        contextUsage,
-        setContextUsage,
-        elapsedSeconds,
-        retryStatus,
-        setRetryStatus,
-        animationFrame,
-        codebaseSearchStatus,
-        setCodebaseSearchStatus,
-    };
-}

package/dist/hooks/useTerminalFocus.d.ts

@@ -1,28 +0,0 @@
-/**
- * Hook to detect terminal window focus state.
- * Returns true when terminal has focus, false otherwise.
- *
- * Uses ANSI escape sequences to detect focus events:
- * - ESC[I (\x1b[I) - Focus gained
- * - ESC[O (\x1b[O) - Focus lost
- *
- * Cross-platform support:
- * - ✅ Windows Terminal
- * - ✅ macOS Terminal.app, iTerm2
- * - ✅ Linux: GNOME Terminal, Konsole, Alacritty, kitty, etc.
- *
- * Note: Older or minimal terminals that don't support focus reporting
- * will simply ignore the escape sequences and cursor will remain visible.
- *
- * Also provides a function to check if input contains focus events
- * so they can be filtered from normal input processing.
- *
- * Auto-focus recovery: If user input is detected while in unfocused state,
- * automatically restore focus state to ensure cursor visibility during
- * operations like Shift+drag file drop where focus events may be delayed.
- */
-export declare function useTerminalFocus(): {
-    hasFocus: boolean;
-    isFocusEvent: (input: string) => boolean;
-    ensureFocus: () => void;
-};

package/dist/hooks/useTerminalFocus.js

@@ -1,87 +0,0 @@
-import { useState, useEffect } from 'react';
-/**
- * Hook to detect terminal window focus state.
- * Returns true when terminal has focus, false otherwise.
- *
- * Uses ANSI escape sequences to detect focus events:
- * - ESC[I (\x1b[I) - Focus gained
- * - ESC[O (\x1b[O) - Focus lost
- *
- * Cross-platform support:
- * - ✅ Windows Terminal
- * - ✅ macOS Terminal.app, iTerm2
- * - ✅ Linux: GNOME Terminal, Konsole, Alacritty, kitty, etc.
- *
- * Note: Older or minimal terminals that don't support focus reporting
- * will simply ignore the escape sequences and cursor will remain visible.
- *
- * Also provides a function to check if input contains focus events
- * so they can be filtered from normal input processing.
- *
- * Auto-focus recovery: If user input is detected while in unfocused state,
- * automatically restore focus state to ensure cursor visibility during
- * operations like Shift+drag file drop where focus events may be delayed.
- */
-export function useTerminalFocus() {
-    const [hasFocus, setHasFocus] = useState(true); // Default to focused
-    useEffect(() => {
-        let syncTimer = null;
-        // Set up listener first
-        const handleData = (data) => {
-            const str = data.toString();
-            // Focus gained: ESC[I
-            if (str === '\x1b[I') {
-                setHasFocus(true);
-                return;
-            }
-            // Focus lost: ESC[O
-            if (str === '\x1b[O') {
-                setHasFocus(false);
-                return;
-            }
-            // Auto-recovery: If we receive any input that's NOT a focus event
-            // while in unfocused state, treat it as an implicit focus gain.
-            // This handles cases where focus events are delayed (e.g., Shift+drag operations)
-            // Filter out escape sequences and other non-printable characters
-            const isPrintableInput = str.length > 0 &&
-                !str.startsWith('\x1b') && // Not an escape sequence
-                !/^[\x00-\x1f\x7f]+$/.test(str); // Not only control characters
-            if (!hasFocus && isPrintableInput) {
-                setHasFocus(true);
-            }
-        };
-        // Listen to stdin data
-        process.stdin.on('data', handleData);
-        // Enable focus reporting AFTER listener is set up
-        // Add a small delay to ensure listener is fully registered
-        const enableTimer = setTimeout(() => {
-            // ESC[?1004h - Enable focus events
-            process.stdout.write('\x1b[?1004h');
-            // After enabling focus reporting, assume terminal has focus
-            // This ensures cursor is visible after component remount (e.g., after /clear)
-            // The terminal will send ESC[O if it doesn't have focus
-            syncTimer = setTimeout(() => {
-                setHasFocus(true);
-            }, 100);
-        }, 50);
-        return () => {
-            clearTimeout(enableTimer);
-            if (syncTimer) {
-                clearTimeout(syncTimer);
-            }
-            // Disable focus reporting on cleanup
-            // ESC[?1004l - Disable focus events
-            process.stdout.write('\x1b[?1004l');
-            process.stdin.off('data', handleData);
-        };
-    }, []); // Remove hasFocus from dependencies to avoid re-running effect
-    // Helper function to check if input is a focus event
-    const isFocusEvent = (input) => {
-        return input === '\x1b[I' || input === '\x1b[O';
-    };
-    // Manual focus restoration function (can be called externally if needed)
-    const ensureFocus = () => {
-        setHasFocus(true);
-    };
-    return { hasFocus, isFocusEvent, ensureFocus };
-}

package/dist/hooks/useTerminalSize.d.ts

@@ -1,4 +0,0 @@
-export declare function useTerminalSize(): {
-    columns: number;
-    rows: number;
-};

package/dist/hooks/useTerminalSize.js

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

package/dist/hooks/useTodoPicker.d.ts

@@ -1,16 +0,0 @@
-import { TextBuffer } from '../utils/textBuffer.js';
-import { type TodoItem } from '../utils/todoScanner.js';
-export declare function useTodoPicker(buffer: TextBuffer, triggerUpdate: () => void, projectRoot: string): {
-    showTodoPicker: boolean;
-    setShowTodoPicker: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-    todoSelectedIndex: number;
-    setTodoSelectedIndex: import("react").Dispatch<import("react").SetStateAction<number>>;
-    todos: TodoItem[];
-    selectedTodos: Set<string>;
-    toggleTodoSelection: () => void;
-    confirmTodoSelection: () => void;
-    isLoading: boolean;
-    searchQuery: string;
-    setSearchQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
-    totalTodoCount: number;
-};

package/dist/hooks/useTodoPicker.js

@@ -1,94 +0,0 @@
-import { useState, useCallback, useEffect, useMemo } from 'react';
-import { scanProjectTodos } from '../utils/todoScanner.js';
-export function useTodoPicker(buffer, triggerUpdate, projectRoot) {
-    const [showTodoPicker, setShowTodoPicker] = useState(false);
-    const [todoSelectedIndex, setTodoSelectedIndex] = useState(0);
-    const [allTodos, setAllTodos] = useState([]);
-    const [selectedTodos, setSelectedTodos] = useState(new Set());
-    const [isLoading, setIsLoading] = useState(false);
-    const [searchQuery, setSearchQuery] = useState('');
-    // Filter todos based on search query
-    const filteredTodos = useMemo(() => {
-        if (!searchQuery.trim()) {
-            return allTodos;
-        }
-        const query = searchQuery.toLowerCase();
-        return allTodos.filter(todo => todo.content.toLowerCase().includes(query) ||
-            todo.file.toLowerCase().includes(query));
-    }, [allTodos, searchQuery]);
-    // Load todos when picker is shown
-    useEffect(() => {
-        if (showTodoPicker) {
-            setIsLoading(true);
-            setSearchQuery('');
-            setTodoSelectedIndex(0);
-            setSelectedTodos(new Set());
-            // Use setTimeout to allow UI to update with loading state
-            setTimeout(() => {
-                const foundTodos = scanProjectTodos(projectRoot);
-                setAllTodos(foundTodos);
-                setIsLoading(false);
-            }, 0);
-        }
-    }, [showTodoPicker, projectRoot]);
-    // Toggle selection of current todo
-    const toggleTodoSelection = useCallback(() => {
-        if (filteredTodos.length > 0 && todoSelectedIndex < filteredTodos.length) {
-            const todo = filteredTodos[todoSelectedIndex];
-            if (todo) {
-                setSelectedTodos(prev => {
-                    const newSet = new Set(prev);
-                    if (newSet.has(todo.id)) {
-                        newSet.delete(todo.id);
-                    }
-                    else {
-                        newSet.add(todo.id);
-                    }
-                    return newSet;
-                });
-                triggerUpdate();
-            }
-        }
-    }, [filteredTodos, todoSelectedIndex, triggerUpdate]);
-    // Confirm selection and insert into buffer
-    const confirmTodoSelection = useCallback(() => {
-        if (selectedTodos.size === 0) {
-            // If no todos selected, just close the picker
-            setShowTodoPicker(false);
-            setTodoSelectedIndex(0);
-            triggerUpdate();
-            return;
-        }
-        // Build the text to insert
-        const selectedTodoItems = allTodos.filter(todo => selectedTodos.has(todo.id));
-        const todoTexts = selectedTodoItems.map(todo => `<${todo.file}:${todo.line}> ${todo.content}`);
-        // Clear buffer and insert selected todos
-        const currentText = buffer.getFullText().trim();
-        buffer.setText('');
-        if (currentText) {
-            buffer.insert(currentText + '\n' + todoTexts.join('\n'));
-        }
-        else {
-            buffer.insert(todoTexts.join('\n'));
-        }
-        // Reset state
-        setShowTodoPicker(false);
-        setTodoSelectedIndex(0);
-        setSelectedTodos(new Set());
-        triggerUpdate();
-    }, [buffer, allTodos, selectedTodos, triggerUpdate]);
-    return {
-        showTodoPicker,
-        setShowTodoPicker,
-        todoSelectedIndex,
-        setTodoSelectedIndex,
-        todos: filteredTodos,
-        selectedTodos,
-        toggleTodoSelection,
-        confirmTodoSelection,
-        isLoading,
-        searchQuery,
-        setSearchQuery,
-        totalTodoCount: allTodos.length,
-    };
-}

package/dist/hooks/useToolConfirmation.d.ts

@@ -1,19 +0,0 @@
-import type { ToolCall } from '../utils/toolExecutor.js';
-import type { ConfirmationResult } from '../ui/components/ToolConfirmation.js';
-export type PendingConfirmation = {
-    tool: ToolCall;
-    batchToolNames?: string;
-    allTools?: ToolCall[];
-    resolve: (result: ConfirmationResult) => void;
-};
-/**
- * Hook for managing tool confirmation state and logic
- */
-export declare function useToolConfirmation(): {
-    pendingToolConfirmation: PendingConfirmation | null;
-    alwaysApprovedTools: Set<string>;
-    requestToolConfirmation: (toolCall: ToolCall, batchToolNames?: string, allTools?: ToolCall[]) => Promise<ConfirmationResult>;
-    isToolAutoApproved: (toolName: string) => boolean;
-    addToAlwaysApproved: (toolName: string) => void;
-    addMultipleToAlwaysApproved: (toolNames: string[]) => void;
-};

package/dist/hooks/useToolConfirmation.js

@@ -1,61 +0,0 @@
-import { useState, useRef, useCallback } from 'react';
-/**
- * Hook for managing tool confirmation state and logic
- */
-export function useToolConfirmation() {
-    const [pendingToolConfirmation, setPendingToolConfirmation] = useState(null);
-    // Use ref for always-approved tools to ensure closure functions always see latest state
-    const alwaysApprovedToolsRef = useRef(new Set());
-    const [alwaysApprovedTools, setAlwaysApprovedTools] = useState(new Set());
-    /**
-     * Request user confirmation for tool execution
-     */
-    const requestToolConfirmation = async (toolCall, batchToolNames, allTools) => {
-        return new Promise(resolve => {
-            setPendingToolConfirmation({
-                tool: toolCall,
-                batchToolNames,
-                allTools,
-                resolve: (result) => {
-                    setPendingToolConfirmation(null);
-                    resolve(result);
-                },
-            });
-        });
-    };
-    /**
-     * Check if a tool is auto-approved
-     * Uses ref to ensure it always sees the latest approved tools
-     */
-    const isToolAutoApproved = useCallback((toolName) => {
-        return (alwaysApprovedToolsRef.current.has(toolName) ||
-            toolName.startsWith('todo-') ||
-            toolName.startsWith('subagent-'));
-    }, []);
-    /**
-     * Add a tool to the always-approved list
-     */
-    const addToAlwaysApproved = useCallback((toolName) => {
-        // Update ref immediately (for closure functions)
-        alwaysApprovedToolsRef.current.add(toolName);
-        // Update state (for UI reactivity)
-        setAlwaysApprovedTools(prev => new Set([...prev, toolName]));
-    }, []);
-    /**
-     * Add multiple tools to the always-approved list
-     */
-    const addMultipleToAlwaysApproved = useCallback((toolNames) => {
-        // Update ref immediately (for closure functions)
-        toolNames.forEach(name => alwaysApprovedToolsRef.current.add(name));
-        // Update state (for UI reactivity)
-        setAlwaysApprovedTools(prev => new Set([...prev, ...toolNames]));
-    }, []);
-    return {
-        pendingToolConfirmation,
-        alwaysApprovedTools,
-        requestToolConfirmation,
-        isToolAutoApproved,
-        addToAlwaysApproved,
-        addMultipleToAlwaysApproved,
-    };
-}

package/dist/hooks/useVSCodeState.d.ts

@@ -1,8 +0,0 @@
-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;
-};