snow-ai 0.2.15 → 0.2.16

package/dist/hooks/useConversation.js

@@ -10,11 +10,15 @@ import { getOpenAiConfig } from '../utils/apiConfig.js';
 import { sessionManager } from '../utils/sessionManager.js';
 import { formatTodoContext } from '../utils/todoPreprocessor.js';
 import { formatToolCallMessage } from '../utils/messageFormatter.js';
+import { vscodeConnection } from '../utils/vscodeConnection.js';
+import { filesystemService } from '../mcp/filesystem.js';
 /**
  * Handle conversation with streaming and tool calls
  */
 export async function handleConversationWithTools(options) {
-    const { userContent, imageContents, controller, messages, saveMessage, setMessages, setStreamTokenCount, setCurrentTodos, requestToolConfirmation, isToolAutoApproved, addMultipleToAlwaysApproved, yoloMode, setContextUsage } = options;
+    const { userContent, imageContents, controller, 
+    // messages, // No longer used - we load from session instead to get complete history with tool calls
+    saveMessage, setMessages, setStreamTokenCount, setCurrentTodos, requestToolConfirmation, isToolAutoApproved, addMultipleToAlwaysApproved, yoloMode, setContextUsage, setIsReasoning, setRetryStatus } = options;
     // Step 1: Ensure session exists and get existing TODOs
     let currentSession = sessionManager.getCurrentSession();
     if (!currentSession) {
@@ -41,12 +45,13 @@ export async function handleConversationWithTools(options) {
             content: todoContext
         });
     }
-    // Add history messages
-    conversationMessages.push(...messages.filter(msg => msg.role !== 'command').map(msg => ({
-        role: msg.role,
-        content: msg.content,
-        images: msg.images
-    })));
+    // Add history messages from session (includes tool_calls and tool results)
+    // Load from session to get complete conversation history with tool interactions
+    const session = sessionManager.getCurrentSession();
+    if (session && session.messages.length > 0) {
+        // Use session messages directly (they are already in API format)
+        conversationMessages.push(...session.messages);
+    }
     // Add current user message
     conversationMessages.push({
         role: 'user',
@@ -87,10 +92,22 @@ export async function handleConversationWithTools(options) {
             // Stream AI response - choose API based on config
             let toolCallAccumulator = ''; // Accumulate tool call deltas for token counting
             let reasoningAccumulator = ''; // Accumulate reasoning summary deltas for token counting (Responses API only)
+            let chunkCount = 0; // Track number of chunks received (to delay clearing retry status)
             // Get or create session for cache key
             const currentSession = sessionManager.getCurrentSession();
             // Use session ID as cache key to ensure same session requests share cache
             const cacheKey = currentSession?.id;
+            // 重试回调函数
+            const onRetry = (error, attempt, nextDelay) => {
+                if (setRetryStatus) {
+                    setRetryStatus({
+                        isRetrying: true,
+                        attempt,
+                        nextDelay,
+                        errorMessage: error.message
+                    });
+                }
+            };
             const streamGenerator = config.requestMethod === 'anthropic'
                 ? createStreamingAnthropicCompletion({
                     model,
@@ -99,14 +116,14 @@ export async function handleConversationWithTools(options) {
                     max_tokens: config.maxTokens || 4096,
                     tools: mcpTools.length > 0 ? mcpTools : undefined,
                     sessionId: currentSession?.id
-                }, controller.signal)
+                }, controller.signal, onRetry)
                 : config.requestMethod === 'gemini'
                     ? createStreamingGeminiCompletion({
                         model,
                         messages: conversationMessages,
                         temperature: 0,
                         tools: mcpTools.length > 0 ? mcpTools : undefined
-                    }, controller.signal)
+                    }, controller.signal, onRetry)
                     : config.requestMethod === 'responses'
                         ? createStreamingResponse({
                             model,
@@ -114,18 +131,32 @@ export async function handleConversationWithTools(options) {
                             temperature: 0,
                             tools: mcpTools.length > 0 ? mcpTools : undefined,
                             prompt_cache_key: cacheKey // Use session ID as cache key
-                        }, controller.signal)
+                        }, controller.signal, onRetry)
                         : createStreamingChatCompletion({
                             model,
                             messages: conversationMessages,
                             temperature: 0,
                             tools: mcpTools.length > 0 ? mcpTools : undefined
-                        }, controller.signal);
+                        }, controller.signal, onRetry);
             for await (const chunk of streamGenerator) {
                 if (controller.signal.aborted)
                     break;
-                if (chunk.type === 'content' && chunk.content) {
+                // Clear retry status after a delay when first chunk arrives
+                // This gives users time to see the retry message (500ms delay)
+                chunkCount++;
+                if (setRetryStatus && chunkCount === 1) {
+                    setTimeout(() => {
+                        setRetryStatus(null);
+                    }, 500);
+                }
+                if (chunk.type === 'reasoning_started') {
+                    // Reasoning started (Responses API only) - set reasoning state
+                    setIsReasoning?.(true);
+                }
+                else if (chunk.type === 'content' && chunk.content) {
                     // Accumulate content and update token count
+                    // When content starts, reasoning is done
+                    setIsReasoning?.(false);
                     streamedContent += chunk.content;
                     try {
                         const tokens = encoder.encode(streamedContent + toolCallAccumulator + reasoningAccumulator);
@@ -236,66 +267,117 @@ export async function handleConversationWithTools(options) {
                 }
                 else if (toolsNeedingConfirmation.length > 0) {
                     const firstTool = toolsNeedingConfirmation[0]; // Safe: length > 0 guarantees this exists
-                    // Pass all tools for proper display in confirmation UI
-                    const allTools = toolsNeedingConfirmation.length > 1
-                        ? toolsNeedingConfirmation
-                        : undefined;
-                    // Use first tool for confirmation UI, but apply result to all
-                    const confirmation = await requestToolConfirmation(firstTool, undefined, allTools);
-                    if (confirmation === 'reject') {
-                        // Remove pending tool messages
-                        setMessages(prev => prev.filter(msg => !msg.toolPending));
-                        // User rejected - end conversation
-                        setMessages(prev => [...prev, {
-                                role: 'assistant',
-                                content: 'Tool call rejected, session ended',
-                                streaming: false
-                            }]);
-                        // End streaming immediately
-                        if (options.setIsStreaming) {
-                            options.setIsStreaming(false);
+                    // Check if we should use DIFF+APPLY for filesystem tools
+                    let usedDiffApply = false;
+                    if (vscodeConnection.isConnected()) {
+                        // Try to use DIFF+APPLY for filesystem_create or filesystem_edit
+                        if (firstTool.function.name === 'filesystem-create' || firstTool.function.name === 'filesystem-edit') {
+                            try {
+                                const args = JSON.parse(firstTool.function.arguments);
+                                if (firstTool.function.name === 'filesystem-create') {
+                                    // For create, show diff with empty old content
+                                    const confirmation = await vscodeConnection.requestDiffApply(args.filePath, '', // Empty old content for new file
+                                    args.content);
+                                    if (confirmation === 'reject') {
+                                        // Remove pending tool messages
+                                        setMessages(prev => prev.filter(msg => !msg.toolPending));
+                                        setMessages(prev => [...prev, {
+                                                role: 'assistant',
+                                                content: 'Tool call rejected, session ended',
+                                                streaming: false
+                                            }]);
+                                        if (options.setIsStreaming) {
+                                            options.setIsStreaming(false);
+                                        }
+                                        encoder.free();
+                                        return;
+                                    }
+                                    if (confirmation === 'approve_always') {
+                                        addMultipleToAlwaysApproved([firstTool.function.name]);
+                                        sessionApprovedTools.add(firstTool.function.name);
+                                    }
+                                    approvedTools.push(...toolsNeedingConfirmation);
+                                    usedDiffApply = true;
+                                }
+                                else if (firstTool.function.name === 'filesystem-edit') {
+                                    // For edit, read the file first to get old content
+                                    const fileContent = await filesystemService.getFileContent(args.filePath, args.startLine, args.endLine);
+                                    const confirmation = await vscodeConnection.requestDiffApply(args.filePath, fileContent.content, args.newContent);
+                                    if (confirmation === 'reject') {
+                                        // Remove pending tool messages
+                                        setMessages(prev => prev.filter(msg => !msg.toolPending));
+                                        setMessages(prev => [...prev, {
+                                                role: 'assistant',
+                                                content: 'Tool call rejected, session ended',
+                                                streaming: false
+                                            }]);
+                                        if (options.setIsStreaming) {
+                                            options.setIsStreaming(false);
+                                        }
+                                        encoder.free();
+                                        return;
+                                    }
+                                    if (confirmation === 'approve_always') {
+                                        addMultipleToAlwaysApproved([firstTool.function.name]);
+                                        sessionApprovedTools.add(firstTool.function.name);
+                                    }
+                                    approvedTools.push(...toolsNeedingConfirmation);
+                                    usedDiffApply = true;
+                                }
+                            }
+                            catch (error) {
+                                // If DIFF+APPLY fails, fall back to regular confirmation
+                                console.error('Failed to use DIFF+APPLY:', error);
+                            }
                         }
-                        encoder.free();
-                        return; // Exit the conversation loop
                     }
-                    // If approved_always, add ALL these tools to both global and session-approved sets
-                    if (confirmation === 'approve_always') {
-                        const toolNamesToAdd = toolsNeedingConfirmation.map(t => t.function.name);
-                        // Add to global state (async, for future sessions)
-                        addMultipleToAlwaysApproved(toolNamesToAdd);
-                        // Add to local session set (sync, for this conversation)
-                        toolNamesToAdd.forEach(name => sessionApprovedTools.add(name));
+                    // If we didn't use DIFF+APPLY, fall back to regular CLI confirmation
+                    if (!usedDiffApply) {
+                        // Pass all tools for proper display in confirmation UI
+                        const allTools = toolsNeedingConfirmation.length > 1
+                            ? toolsNeedingConfirmation
+                            : undefined;
+                        // Use first tool for confirmation UI, but apply result to all
+                        const confirmation = await requestToolConfirmation(firstTool, undefined, allTools);
+                        if (confirmation === 'reject') {
+                            // Remove pending tool messages
+                            setMessages(prev => prev.filter(msg => !msg.toolPending));
+                            // User rejected - end conversation
+                            setMessages(prev => [...prev, {
+                                    role: 'assistant',
+                                    content: 'Tool call rejected, session ended',
+                                    streaming: false
+                                }]);
+                            // End streaming immediately
+                            if (options.setIsStreaming) {
+                                options.setIsStreaming(false);
+                            }
+                            encoder.free();
+                            return; // Exit the conversation loop
+                        }
+                        // If approved_always, add ALL these tools to both global and session-approved sets
+                        if (confirmation === 'approve_always') {
+                            const toolNamesToAdd = toolsNeedingConfirmation.map(t => t.function.name);
+                            // Add to global state (async, for future sessions)
+                            addMultipleToAlwaysApproved(toolNamesToAdd);
+                            // Add to local session set (sync, for this conversation)
+                            toolNamesToAdd.forEach(name => sessionApprovedTools.add(name));
+                        }
+                        // Add all tools to approved list
+                        approvedTools.push(...toolsNeedingConfirmation);
                     }
-                    // Add all tools to approved list
-                    approvedTools.push(...toolsNeedingConfirmation);
                 }
                 // Execute approved tools
                 const toolResults = await executeToolCalls(approvedTools);
                 // Check if there are TODO related tool calls, if yes refresh TODO list
-                // Only show TODO panel for todo-update, not for other todo operations
-                const shouldShowTodoPanel = approvedTools.some(t => t.function.name === 'todo-update');
                 const hasTodoTools = approvedTools.some(t => t.function.name.startsWith('todo-'));
+                const hasTodoUpdateTools = approvedTools.some(t => t.function.name === 'todo-update');
                 if (hasTodoTools) {
                     const session = sessionManager.getCurrentSession();
                     if (session) {
                         const updatedTodoList = await todoService.getTodoList(session.id);
                         if (updatedTodoList) {
                             setCurrentTodos(updatedTodoList.todos);
-                            // Only show TODO panel for update operations
-                            if (shouldShowTodoPanel) {
-                                // Remove any existing TODO tree messages and add a new one
-                                setMessages(prev => {
-                                    // Filter out previous TODO tree messages
-                                    const withoutTodoTree = prev.filter(m => !m.showTodoTree);
-                                    // Add new TODO tree message
-                                    return [...withoutTodoTree, {
-                                            role: 'assistant',
-                                            content: '[TODO List Updated]',
-                                            streaming: false,
-                                            showTodoTree: true
-                                        }];
-                                });
-                            }
                         }
                     }
                 }
@@ -368,6 +450,18 @@ export async function handleConversationWithTools(options) {
                         console.error('Failed to save tool result:', error);
                     });
                 }
+                // After all tool results are processed, show TODO panel if there were todo-update calls
+                if (hasTodoUpdateTools) {
+                    setMessages(prev => [
+                        ...prev,
+                        {
+                            role: 'assistant',
+                            content: '',
+                            streaming: false,
+                            showTodoTree: true
+                        }
+                    ]);
+                }
                 // Check if there are pending user messages to insert
                 if (options.getPendingMessages && options.clearPendingMessages) {
                     const pendingMessages = options.getPendingMessages();

package/dist/hooks/useFilePicker.d.ts

@@ -0,0 +1,17 @@
+import { TextBuffer } from '../utils/textBuffer.js';
+import { FileListRef } from '../ui/components/FileList.js';
+export declare function useFilePicker(buffer: TextBuffer, triggerUpdate: () => void): {
+    showFilePicker: boolean;
+    setShowFilePicker: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    fileSelectedIndex: number;
+    setFileSelectedIndex: import("react").Dispatch<import("react").SetStateAction<number>>;
+    fileQuery: string;
+    setFileQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    atSymbolPosition: number;
+    setAtSymbolPosition: import("react").Dispatch<import("react").SetStateAction<number>>;
+    filteredFileCount: number;
+    updateFilePickerState: (text: string, cursorPos: number) => void;
+    handleFileSelect: (filePath: string) => Promise<void>;
+    handleFilteredCountChange: (count: number) => void;
+    fileListRef: import("react").RefObject<FileListRef>;
+};

package/dist/hooks/useFilePicker.js

@@ -0,0 +1,91 @@
+import { useState, useCallback, useRef } from 'react';
+export function useFilePicker(buffer, triggerUpdate) {
+    const [showFilePicker, setShowFilePicker] = useState(false);
+    const [fileSelectedIndex, setFileSelectedIndex] = useState(0);
+    const [fileQuery, setFileQuery] = useState('');
+    const [atSymbolPosition, setAtSymbolPosition] = useState(-1);
+    const [filteredFileCount, setFilteredFileCount] = useState(0);
+    const fileListRef = useRef(null);
+    // Update file picker state
+    const updateFilePickerState = useCallback((text, cursorPos) => {
+        if (!text.includes('@')) {
+            if (showFilePicker) {
+                setShowFilePicker(false);
+                setFileSelectedIndex(0);
+                setFileQuery('');
+                setAtSymbolPosition(-1);
+            }
+            return;
+        }
+        // Find the last '@' symbol before the cursor
+        const beforeCursor = text.slice(0, cursorPos);
+        const lastAtIndex = beforeCursor.lastIndexOf('@');
+        if (lastAtIndex !== -1) {
+            // Check if there's no space between '@' and cursor
+            const afterAt = beforeCursor.slice(lastAtIndex + 1);
+            if (!afterAt.includes(' ') && !afterAt.includes('\n')) {
+                if (!showFilePicker ||
+                    fileQuery !== afterAt ||
+                    atSymbolPosition !== lastAtIndex) {
+                    setShowFilePicker(true);
+                    setFileSelectedIndex(0);
+                    setFileQuery(afterAt);
+                    setAtSymbolPosition(lastAtIndex);
+                }
+                return;
+            }
+        }
+        // Hide file picker if no valid @ context found
+        if (showFilePicker) {
+            setShowFilePicker(false);
+            setFileSelectedIndex(0);
+            setFileQuery('');
+            setAtSymbolPosition(-1);
+        }
+    }, [showFilePicker, fileQuery, atSymbolPosition]);
+    // Handle file selection
+    const handleFileSelect = useCallback(async (filePath) => {
+        if (atSymbolPosition !== -1) {
+            const text = buffer.getFullText();
+            const cursorPos = buffer.getCursorPosition();
+            // Replace @query with @filePath + space
+            const beforeAt = text.slice(0, atSymbolPosition);
+            const afterCursor = text.slice(cursorPos);
+            const newText = beforeAt + '@' + filePath + ' ' + afterCursor;
+            // Set the new text and position cursor after the inserted file path + space
+            buffer.setText(newText);
+            // Calculate cursor position after the inserted file path + space
+            // Reset cursor to beginning, then move to correct position
+            for (let i = 0; i < atSymbolPosition + filePath.length + 2; i++) {
+                // +2 for @ and space
+                if (i < buffer.getFullText().length) {
+                    buffer.moveRight();
+                }
+            }
+            setShowFilePicker(false);
+            setFileSelectedIndex(0);
+            setFileQuery('');
+            setAtSymbolPosition(-1);
+            triggerUpdate();
+        }
+    }, [atSymbolPosition, buffer, triggerUpdate]);
+    // Handle filtered file count change
+    const handleFilteredCountChange = useCallback((count) => {
+        setFilteredFileCount(count);
+    }, []);
+    return {
+        showFilePicker,
+        setShowFilePicker,
+        fileSelectedIndex,
+        setFileSelectedIndex,
+        fileQuery,
+        setFileQuery,
+        atSymbolPosition,
+        setAtSymbolPosition,
+        filteredFileCount,
+        updateFilePickerState,
+        handleFileSelect,
+        handleFilteredCountChange,
+        fileListRef,
+    };
+}

package/dist/hooks/useHistoryNavigation.d.ts

@@ -0,0 +1,21 @@
+import { TextBuffer } from '../utils/textBuffer.js';
+type ChatMessage = {
+    role: string;
+    content: string;
+};
+export declare function useHistoryNavigation(buffer: TextBuffer, triggerUpdate: () => void, chatHistory: ChatMessage[], onHistorySelect?: (selectedIndex: number, message: string) => void): {
+    showHistoryMenu: boolean;
+    setShowHistoryMenu: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    historySelectedIndex: number;
+    setHistorySelectedIndex: import("react").Dispatch<import("react").SetStateAction<number>>;
+    escapeKeyCount: number;
+    setEscapeKeyCount: import("react").Dispatch<import("react").SetStateAction<number>>;
+    escapeKeyTimer: import("react").MutableRefObject<NodeJS.Timeout | null>;
+    getUserMessages: () => {
+        label: string;
+        value: string;
+        infoText: string;
+    }[];
+    handleHistorySelect: (value: string) => void;
+};
+export {};

package/dist/hooks/useHistoryNavigation.js

@@ -0,0 +1,50 @@
+import { useState, useCallback, useRef, useEffect } from 'react';
+export function useHistoryNavigation(buffer, triggerUpdate, chatHistory, onHistorySelect) {
+    const [showHistoryMenu, setShowHistoryMenu] = useState(false);
+    const [historySelectedIndex, setHistorySelectedIndex] = useState(0);
+    const [escapeKeyCount, setEscapeKeyCount] = useState(0);
+    const escapeKeyTimer = useRef(null);
+    // Cleanup timer on unmount
+    useEffect(() => {
+        return () => {
+            if (escapeKeyTimer.current) {
+                clearTimeout(escapeKeyTimer.current);
+            }
+        };
+    }, []);
+    // Get user messages from chat history for navigation
+    const getUserMessages = useCallback(() => {
+        const userMessages = chatHistory
+            .map((msg, index) => ({ ...msg, originalIndex: index }))
+            .filter(msg => msg.role === 'user' && msg.content.trim());
+        // Keep original order (oldest first, newest last) and map with display numbers
+        return userMessages.map((msg, index) => ({
+            label: `${index + 1}. ${msg.content.slice(0, 50)}${msg.content.length > 50 ? '...' : ''}`,
+            value: msg.originalIndex.toString(),
+            infoText: msg.content,
+        }));
+    }, [chatHistory]);
+    // Handle history selection
+    const handleHistorySelect = useCallback((value) => {
+        const selectedIndex = parseInt(value, 10);
+        const selectedMessage = chatHistory[selectedIndex];
+        if (selectedMessage && onHistorySelect) {
+            // Put the message content in the input buffer
+            buffer.setText(selectedMessage.content);
+            setShowHistoryMenu(false);
+            triggerUpdate();
+            onHistorySelect(selectedIndex, selectedMessage.content);
+        }
+    }, [chatHistory, onHistorySelect, buffer, triggerUpdate]);
+    return {
+        showHistoryMenu,
+        setShowHistoryMenu,
+        historySelectedIndex,
+        setHistorySelectedIndex,
+        escapeKeyCount,
+        setEscapeKeyCount,
+        escapeKeyTimer,
+        getUserMessages,
+        handleHistorySelect,
+    };
+}

package/dist/hooks/useInputBuffer.d.ts

@@ -0,0 +1,6 @@
+import { TextBuffer, Viewport } from '../utils/textBuffer.js';
+export declare function useInputBuffer(viewport: Viewport): {
+    buffer: TextBuffer;
+    triggerUpdate: () => void;
+    forceUpdate: import("react").Dispatch<import("react").SetStateAction<{}>>;
+};

package/dist/hooks/useInputBuffer.js

@@ -0,0 +1,29 @@
+import { useState, useCallback, useEffect, useRef } from 'react';
+import { TextBuffer } from '../utils/textBuffer.js';
+export function useInputBuffer(viewport) {
+    const [, forceUpdate] = useState({});
+    const lastUpdateTime = useRef(0);
+    // Force re-render when buffer changes
+    const triggerUpdate = useCallback(() => {
+        const now = Date.now();
+        lastUpdateTime.current = now;
+        forceUpdate({});
+    }, []);
+    const [buffer] = useState(() => new TextBuffer(viewport, triggerUpdate));
+    // Update buffer viewport when viewport changes
+    useEffect(() => {
+        buffer.updateViewport(viewport);
+        triggerUpdate();
+    }, [viewport.width, viewport.height, buffer, triggerUpdate]);
+    // Cleanup buffer on unmount
+    useEffect(() => {
+        return () => {
+            buffer.destroy();
+        };
+    }, [buffer]);
+    return {
+        buffer,
+        triggerUpdate,
+        forceUpdate,
+    };
+}

package/dist/hooks/useKeyboardInput.d.ts

@@ -0,0 +1,51 @@
+import { TextBuffer } from '../utils/textBuffer.js';
+type KeyboardInputOptions = {
+    buffer: TextBuffer;
+    disabled: boolean;
+    triggerUpdate: () => void;
+    forceUpdate: React.Dispatch<React.SetStateAction<{}>>;
+    showCommands: boolean;
+    setShowCommands: (show: boolean) => void;
+    commandSelectedIndex: number;
+    setCommandSelectedIndex: (index: number | ((prev: number) => number)) => void;
+    getFilteredCommands: () => Array<{
+        name: string;
+        description: string;
+    }>;
+    updateCommandPanelState: (text: string) => void;
+    onCommand?: (commandName: string, result: any) => void;
+    showFilePicker: boolean;
+    setShowFilePicker: (show: boolean) => void;
+    fileSelectedIndex: number;
+    setFileSelectedIndex: (index: number | ((prev: number) => number)) => void;
+    fileQuery: string;
+    setFileQuery: (query: string) => void;
+    atSymbolPosition: number;
+    setAtSymbolPosition: (pos: number) => void;
+    filteredFileCount: number;
+    updateFilePickerState: (text: string, cursorPos: number) => void;
+    handleFileSelect: (filePath: string) => Promise<void>;
+    fileListRef: React.RefObject<{
+        getSelectedFile: () => string | null;
+    }>;
+    showHistoryMenu: boolean;
+    setShowHistoryMenu: (show: boolean) => void;
+    historySelectedIndex: number;
+    setHistorySelectedIndex: (index: number | ((prev: number) => number)) => void;
+    escapeKeyCount: number;
+    setEscapeKeyCount: (count: number | ((prev: number) => number)) => void;
+    escapeKeyTimer: React.MutableRefObject<NodeJS.Timeout | null>;
+    getUserMessages: () => Array<{
+        label: string;
+        value: string;
+        infoText: string;
+    }>;
+    handleHistorySelect: (value: string) => void;
+    pasteFromClipboard: () => Promise<void>;
+    onSubmit: (message: string, images?: Array<{
+        data: string;
+        mimeType: string;
+    }>) => void;
+};
+export declare function useKeyboardInput(options: KeyboardInputOptions): void;
+export {};