snow-ai 0.2.18 → 0.2.20

package/dist/hooks/useConversation.js

@@ -10,15 +10,13 @@ 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, // 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;
+    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) {
@@ -35,14 +33,14 @@ export async function handleConversationWithTools(options) {
     const mcpTools = await collectAllMCPTools();
     // Build conversation history with TODO context as pinned user message
     let conversationMessages = [
-        { role: 'system', content: SYSTEM_PROMPT }
+        { role: 'system', content: SYSTEM_PROMPT },
     ];
     // If there are TODOs, add pinned context message at the front
     if (existingTodoList && existingTodoList.todos.length > 0) {
         const todoContext = formatTodoContext(existingTodoList.todos);
         conversationMessages.push({
             role: 'user',
-            content: todoContext
+            content: todoContext,
         });
     }
     // Add history messages from session (includes tool_calls and tool results)
@@ -56,13 +54,13 @@ export async function handleConversationWithTools(options) {
     conversationMessages.push({
         role: 'user',
         content: userContent,
-        images: imageContents
+        images: imageContents,
     });
     // Save user message (directly save API format message)
     saveMessage({
         role: 'user',
         content: userContent,
-        images: imageContents
+        images: imageContents,
     }).catch(error => {
         console.error('Failed to save user message:', error);
     });
@@ -77,8 +75,8 @@ export async function handleConversationWithTools(options) {
     setStreamTokenCount(0);
     const config = getOpenAiConfig();
     const model = options.useBasicModel
-        ? (config.basicModel || config.advancedModel || 'gpt-4.1')
-        : (config.advancedModel || 'gpt-4.1');
+        ? config.basicModel || config.advancedModel || 'gpt-4.1'
+        : config.advancedModel || 'gpt-4.1';
     // Tool calling loop (no limit on rounds)
     let finalAssistantMessage = null;
     // Local set to track approved tools in this conversation (solves async setState issue)
@@ -104,7 +102,7 @@ export async function handleConversationWithTools(options) {
                         isRetrying: true,
                         attempt,
                         nextDelay,
-                        errorMessage: error.message
+                        errorMessage: error.message,
                     });
                 }
             };
@@ -115,14 +113,14 @@ export async function handleConversationWithTools(options) {
                     temperature: 0,
                     max_tokens: config.maxTokens || 4096,
                     tools: mcpTools.length > 0 ? mcpTools : undefined,
-                    sessionId: currentSession?.id
+                    sessionId: currentSession?.id,
                 }, controller.signal, onRetry)
                 : config.requestMethod === 'gemini'
                     ? createStreamingGeminiCompletion({
                         model,
                         messages: conversationMessages,
                         temperature: 0,
-                        tools: mcpTools.length > 0 ? mcpTools : undefined
+                        tools: mcpTools.length > 0 ? mcpTools : undefined,
                     }, controller.signal, onRetry)
                     : config.requestMethod === 'responses'
                         ? createStreamingResponse({
@@ -130,13 +128,13 @@ export async function handleConversationWithTools(options) {
                             messages: conversationMessages,
                             temperature: 0,
                             tools: mcpTools.length > 0 ? mcpTools : undefined,
-                            prompt_cache_key: cacheKey // Use session ID as cache key
+                            prompt_cache_key: cacheKey, // Use session ID as cache key
                         }, controller.signal, onRetry)
                         : createStreamingChatCompletion({
                             model,
                             messages: conversationMessages,
                             temperature: 0,
-                            tools: mcpTools.length > 0 ? mcpTools : undefined
+                            tools: mcpTools.length > 0 ? mcpTools : undefined,
                         }, controller.signal, onRetry);
             for await (const chunk of streamGenerator) {
                 if (controller.signal.aborted)
@@ -215,9 +213,9 @@ export async function handleConversationWithTools(options) {
                         type: 'function',
                         function: {
                             name: tc.function.name,
-                            arguments: tc.function.arguments
-                        }
-                    }))
+                            arguments: tc.function.arguments,
+                        },
+                    })),
                 };
                 conversationMessages.push(assistantMessage);
                 // Save assistant message with tool calls
@@ -234,25 +232,29 @@ export async function handleConversationWithTools(options) {
                     catch (e) {
                         toolArgs = {};
                     }
-                    setMessages(prev => [...prev, {
+                    setMessages(prev => [
+                        ...prev,
+                        {
                             role: 'assistant',
                             content: `⚡ ${toolDisplay.toolName}`,
                             streaming: false,
                             toolCall: {
                                 name: toolCall.function.name,
-                                arguments: toolArgs
+                                arguments: toolArgs,
                             },
                             toolDisplay,
                             toolCallId: toolCall.id, // Store tool call ID for later update
-                            toolPending: true // Mark as pending execution
-                        }]);
+                            toolPending: true, // Mark as pending execution
+                        },
+                    ]);
                 }
                 // Filter tools that need confirmation (not in always-approved list OR session-approved list)
                 const toolsNeedingConfirmation = [];
                 const autoApprovedTools = [];
                 for (const toolCall of receivedToolCalls) {
                     // Check both global approved list and session-approved list
-                    if (isToolAutoApproved(toolCall.function.name) || sessionApprovedTools.has(toolCall.function.name)) {
+                    if (isToolAutoApproved(toolCall.function.name) ||
+                        sessionApprovedTools.has(toolCall.function.name)) {
                         autoApprovedTools.push(toolCall);
                     }
                     else {
@@ -267,105 +269,42 @@ export async function handleConversationWithTools(options) {
                 }
                 else if (toolsNeedingConfirmation.length > 0) {
                     const firstTool = toolsNeedingConfirmation[0]; // Safe: length > 0 guarantees this exists
-                    // 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);
-                            }
+                    // Use regular CLI confirmation
+                    // 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 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);
+                    // 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);
                 }
                 // Execute approved tools
                 const toolResults = await executeToolCalls(approvedTools);
@@ -390,14 +329,19 @@ export async function handleConversationWithTools(options) {
                         const statusText = isError ? `\n  └─ ${result.content}` : '';
                         // Check if this is an edit tool with diff data
                         let editDiffData;
-                        if (toolCall.function.name === 'filesystem-edit' && !isError) {
+                        if ((toolCall.function.name === 'filesystem-edit' ||
+                            toolCall.function.name === 'filesystem-edit_search') &&
+                            !isError) {
                             try {
                                 const resultData = JSON.parse(result.content);
                                 if (resultData.oldContent && resultData.newContent) {
                                     editDiffData = {
                                         oldContent: resultData.oldContent,
                                         newContent: resultData.newContent,
-                                        filename: JSON.parse(toolCall.function.arguments).filePath
+                                        filename: JSON.parse(toolCall.function.arguments).filePath,
+                                        completeOldContent: resultData.completeOldContent,
+                                        completeNewContent: resultData.completeNewContent,
+                                        contextStartLine: resultData.contextStartLine,
                                     };
                                 }
                             }
@@ -415,7 +359,7 @@ export async function handleConversationWithTools(options) {
                                         stdout: resultData.stdout || '',
                                         stderr: resultData.stderr || '',
                                         exitCode: resultData.exitCode || 0,
-                                        command: resultData.command
+                                        command: resultData.command,
                                     };
                                 }
                             }
@@ -430,15 +374,19 @@ export async function handleConversationWithTools(options) {
                                     ...msg,
                                     content: `${statusIcon} ${toolCall.function.name}${statusText}`,
                                     toolPending: false,
-                                    toolCall: editDiffData ? {
-                                        name: toolCall.function.name,
-                                        arguments: editDiffData
-                                    } : terminalResultData ? {
-                                        name: toolCall.function.name,
-                                        arguments: terminalResultData
-                                    } : msg.toolCall,
+                                    toolCall: editDiffData
+                                        ? {
+                                            name: toolCall.function.name,
+                                            arguments: editDiffData,
+                                        }
+                                        : terminalResultData
+                                            ? {
+                                                name: toolCall.function.name,
+                                                arguments: terminalResultData,
+                                            }
+                                            : msg.toolCall,
                                     // Store tool result for preview rendering
-                                    toolResult: !isError ? result.content : undefined
+                                    toolResult: !isError ? result.content : undefined,
                                 };
                             }
                             return msg;
@@ -458,8 +406,8 @@ export async function handleConversationWithTools(options) {
                             role: 'assistant',
                             content: '',
                             streaming: false,
-                            showTodoTree: true
-                        }
+                            showTodoTree: true,
+                        },
                     ]);
                 }
                 // Check if there are pending user messages to insert
@@ -471,17 +419,20 @@ export async function handleConversationWithTools(options) {
                         // Combine multiple pending messages into one
                         const combinedMessage = pendingMessages.join('\n\n');
                         // Add user message to UI
-                        const userMessage = { role: 'user', content: combinedMessage };
+                        const userMessage = {
+                            role: 'user',
+                            content: combinedMessage,
+                        };
                         setMessages(prev => [...prev, userMessage]);
                         // Add user message to conversation history
                         conversationMessages.push({
                             role: 'user',
-                            content: combinedMessage
+                            content: combinedMessage,
                         });
                         // Save user message
                         saveMessage({
                             role: 'user',
-                            content: combinedMessage
+                            content: combinedMessage,
                         }).catch(error => {
                             console.error('Failed to save pending user message:', error);
                         });
@@ -496,13 +447,13 @@ export async function handleConversationWithTools(options) {
                     role: 'assistant',
                     content: streamedContent.trim(),
                     streaming: false,
-                    discontinued: controller.signal.aborted
+                    discontinued: controller.signal.aborted,
                 };
                 setMessages(prev => [...prev, finalAssistantMessage]);
                 // Add to conversation history and save
                 const assistantMessage = {
                     role: 'assistant',
-                    content: streamedContent.trim()
+                    content: streamedContent.trim(),
                 };
                 conversationMessages.push(assistantMessage);
                 saveMessage(assistantMessage).catch(error => {

package/dist/hooks/useKeyboardInput.js

@@ -26,6 +26,15 @@ export function useKeyboardInput(options) {
     useInput((input, key) => {
         if (disabled)
             return;
+        // Shift+Tab - Toggle YOLO mode
+        if (key.shift && key.tab) {
+            executeCommand('yolo').then(result => {
+                if (onCommand) {
+                    onCommand('yolo', result);
+                }
+            });
+            return;
+        }
         // Handle escape key for double-ESC history navigation
         if (key.escape) {
             // Close file picker if open