snow-ai 0.3.5 → 0.3.7

package/dist/hooks/useConversation.js

@@ -3,7 +3,7 @@ import { createStreamingChatCompletion } from '../api/chat.js';
 import { createStreamingResponse } from '../api/responses.js';
 import { createStreamingGeminiCompletion } from '../api/gemini.js';
 import { createStreamingAnthropicCompletion } from '../api/anthropic.js';
-import { SYSTEM_PROMPT } from '../api/systemPrompt.js';
+import { getSystemPrompt } from '../api/systemPrompt.js';
 import { collectAllMCPTools, getTodoService } from '../utils/mcpToolsManager.js';
 import { executeToolCalls } from '../utils/toolExecutor.js';
 import { getOpenAiConfig } from '../utils/apiConfig.js';
@@ -13,6 +13,7 @@ import { formatToolCallMessage } from '../utils/messageFormatter.js';
 import { resourceMonitor } from '../utils/resourceMonitor.js';
 /**
  * Handle conversation with streaming and tool calls
+ * Returns the usage data collected during the conversation
  */
 export async function handleConversationWithTools(options) {
     const { userContent, imageContents, controller, 
@@ -34,7 +35,7 @@ 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: getSystemPrompt() },
     ];
     // If there are TODOs, add pinned context message at the front
     if (existingTodoList && existingTodoList.todos.length > 0) {
@@ -98,6 +99,8 @@ export async function handleConversationWithTools(options) {
         : config.advancedModel || 'gpt-4.1';
     // Tool calling loop (no limit on rounds)
     let finalAssistantMessage = null;
+    // Accumulate usage data across all rounds
+    let accumulatedUsage = null;
     // Local set to track approved tools in this conversation (solves async setState issue)
     const sessionApprovedTools = new Set();
     try {
@@ -108,6 +111,7 @@ export async function handleConversationWithTools(options) {
             }
             let streamedContent = '';
             let receivedToolCalls;
+            let receivedReasoning;
             // 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)
@@ -149,6 +153,7 @@ export async function handleConversationWithTools(options) {
                             messages: conversationMessages,
                             temperature: 0,
                             tools: mcpTools.length > 0 ? mcpTools : undefined,
+                            tool_choice: 'auto',
                             prompt_cache_key: cacheKey, // Use session ID as cache key
                         }, controller.signal, onRetry)
                         : createStreamingChatCompletion({
@@ -211,9 +216,41 @@ export async function handleConversationWithTools(options) {
                 else if (chunk.type === 'tool_calls' && chunk.tool_calls) {
                     receivedToolCalls = chunk.tool_calls;
                 }
+                else if (chunk.type === 'reasoning_data' && chunk.reasoning) {
+                    // Capture reasoning data from Responses API
+                    receivedReasoning = chunk.reasoning;
+                }
                 else if (chunk.type === 'usage' && chunk.usage) {
-                    // Capture usage information
+                    // Capture usage information both in state and locally
                     setContextUsage(chunk.usage);
+                    // Note: Usage is now saved at API layer (chat.ts, anthropic.ts, etc.)
+                    // No need to call onUsageUpdate here to avoid duplicate saves
+                    // Accumulate for final return (UI display purposes)
+                    if (!accumulatedUsage) {
+                        accumulatedUsage = {
+                            prompt_tokens: chunk.usage.prompt_tokens || 0,
+                            completion_tokens: chunk.usage.completion_tokens || 0,
+                            total_tokens: chunk.usage.total_tokens || 0,
+                            cache_creation_input_tokens: chunk.usage.cache_creation_input_tokens,
+                            cache_read_input_tokens: chunk.usage.cache_read_input_tokens,
+                        };
+                    }
+                    else {
+                        // Add to existing usage for UI display
+                        accumulatedUsage.prompt_tokens += chunk.usage.prompt_tokens || 0;
+                        accumulatedUsage.completion_tokens += chunk.usage.completion_tokens || 0;
+                        accumulatedUsage.total_tokens += chunk.usage.total_tokens || 0;
+                        if (chunk.usage.cache_creation_input_tokens !== undefined) {
+                            accumulatedUsage.cache_creation_input_tokens =
+                                (accumulatedUsage.cache_creation_input_tokens || 0) +
+                                    chunk.usage.cache_creation_input_tokens;
+                        }
+                        if (chunk.usage.cache_read_input_tokens !== undefined) {
+                            accumulatedUsage.cache_read_input_tokens =
+                                (accumulatedUsage.cache_read_input_tokens || 0) +
+                                    chunk.usage.cache_read_input_tokens;
+                        }
+                    }
                 }
             }
             // Reset token count after stream ends
@@ -238,6 +275,7 @@ export async function handleConversationWithTools(options) {
                             arguments: tc.function.arguments,
                         },
                     })),
+                    reasoning: receivedReasoning, // Include reasoning data for caching
                 };
                 conversationMessages.push(assistantMessage);
                 // Save assistant message with tool calls
@@ -326,7 +364,7 @@ export async function handleConversationWithTools(options) {
                             options.setIsStreaming(false);
                         }
                         freeEncoder();
-                        return; // Exit the conversation loop
+                        return { usage: accumulatedUsage }; // Exit the conversation loop
                     }
                     // If approved_always, add ALL these tools to both global and session-approved sets
                     if (confirmation === 'approve_always') {
@@ -531,10 +569,24 @@ export async function handleConversationWithTools(options) {
                 for (const result of toolResults) {
                     const toolCall = receivedToolCalls.find(tc => tc.id === result.tool_call_id);
                     if (toolCall) {
-                        // Skip displaying result for sub-agent tools here
-                        // Sub-agent results will be added by the callback after internal messages
+                        // Special handling for sub-agent tools - show completion message
+                        // Pass the full JSON result to ToolResultPreview for proper parsing
                         if (toolCall.function.name.startsWith('subagent-')) {
-                            // Still save the tool result to conversation history
+                            const isError = result.content.startsWith('Error:');
+                            const statusIcon = isError ? '✗' : '✓';
+                            const statusText = isError ? `\n  └─ ${result.content}` : '';
+                            // Display subagent completion message in main flow
+                            setMessages(prev => [
+                                ...prev,
+                                {
+                                    role: 'assistant',
+                                    content: `${statusIcon} ${toolCall.function.name}${statusText}`,
+                                    streaming: false,
+                                    // Pass the full result.content for ToolResultPreview to parse
+                                    toolResult: !isError ? result.content : undefined,
+                                },
+                            ]);
+                            // Save the tool result to conversation history
                             conversationMessages.push(result);
                             saveMessage(result).catch(error => {
                                 console.error('Failed to save tool result:', error);
@@ -638,7 +690,8 @@ export async function handleConversationWithTools(options) {
                 // Continue loop to get next response
                 continue;
             }
-            // No tool calls - display text content if any
+            // No tool calls - conversation is complete
+            // Display text content if any
             if (streamedContent.trim()) {
                 finalAssistantMessage = {
                     role: 'assistant',
@@ -651,13 +704,14 @@ export async function handleConversationWithTools(options) {
                 const assistantMessage = {
                     role: 'assistant',
                     content: streamedContent.trim(),
+                    reasoning: receivedReasoning, // Include reasoning data for caching
                 };
                 conversationMessages.push(assistantMessage);
                 saveMessage(assistantMessage).catch(error => {
                     console.error('Failed to save assistant message:', error);
                 });
             }
-            // Conversation complete
+            // Conversation complete - exit the loop
             break;
         }
         // Free encoder
@@ -667,4 +721,6 @@ export async function handleConversationWithTools(options) {
         freeEncoder();
         throw error;
     }
+    // Return the accumulated usage data
+    return { usage: accumulatedUsage };
 }

package/dist/hooks/useKeyboardInput.js

@@ -223,6 +223,25 @@ export function useKeyboardInput(options) {
         if (key.return) {
             const message = buffer.getFullText().trim();
             if (message) {
+                // Check if message is a command with arguments (e.g., /review [note])
+                if (message.startsWith('/')) {
+                    const commandMatch = message.match(/^\/(\w+)(?:\s+(.+))?$/);
+                    if (commandMatch && commandMatch[1]) {
+                        const commandName = commandMatch[1];
+                        const commandArgs = commandMatch[2];
+                        // Execute command with arguments
+                        executeCommand(commandName, commandArgs).then(result => {
+                            if (onCommand) {
+                                onCommand(commandName, result);
+                            }
+                        });
+                        buffer.setText('');
+                        setShowCommands(false);
+                        setCommandSelectedIndex(0);
+                        triggerUpdate();
+                        return;
+                    }
+                }
                 // Get images data, but only include images whose placeholders still exist
                 const currentText = buffer.text; // Use internal text (includes placeholders)
                 const allImages = buffer.getImages();

package/dist/hooks/useTerminalFocus.js

@@ -25,6 +25,7 @@ import { useState, useEffect } from 'react';
 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();
@@ -53,18 +54,27 @@ export function useTerminalFocus() {
         process.stdin.on('data', handleData);
         // Enable focus reporting AFTER listener is set up
         // Add a small delay to ensure listener is fully registered
-        const timer = setTimeout(() => {
+        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(timer);
+            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);
         };
-    }, [hasFocus]); // Add hasFocus to dependencies to access current state
+    }, []); // 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';

package/dist/mcp/aceCodeSearch.d.ts

@@ -1,43 +1,4 @@
-/**
- * ACE Code Search Types
- */
-export interface CodeSymbol {
-    name: string;
-    type: 'function' | 'class' | 'method' | 'variable' | 'constant' | 'interface' | 'type' | 'enum' | 'import' | 'export';
-    filePath: string;
-    line: number;
-    column: number;
-    endLine?: number;
-    endColumn?: number;
-    signature?: string;
-    scope?: string;
-    language: string;
-    context?: string;
-}
-export interface CodeReference {
-    symbol: string;
-    filePath: string;
-    line: number;
-    column: number;
-    context: string;
-    referenceType: 'definition' | 'usage' | 'import' | 'type';
-}
-export interface SemanticSearchResult {
-    query: string;
-    symbols: CodeSymbol[];
-    references: CodeReference[];
-    totalResults: number;
-    searchTime: number;
-}
-export interface ASTNode {
-    type: string;
-    name?: string;
-    line: number;
-    column: number;
-    endLine?: number;
-    endColumn?: number;
-    children?: ASTNode[];
-}
+import type { CodeSymbol, CodeReference, SemanticSearchResult } from './types/aceCodeSearch.types.js';
 export declare class ACECodeSearchService {
     private basePath;
     private indexCache;
@@ -48,47 +9,17 @@ export declare class ACECodeSearchService {
     private fileModTimes;
     private customExcludes;
     private excludesLoaded;
-    private regexCache;
     private fileContentCache;
-    private readonly FILE_CONTENT_CACHE_SIZE;
-    private readonly DEFAULT_EXCLUDES;
+    private regexCache;
     constructor(basePath?: string);
     /**
      * Load custom exclusion patterns from .gitignore and .snowignore
      */
     private loadExclusionPatterns;
-    /**
-     * Check if a directory should be excluded based on exclusion patterns
-     */
-    private shouldExcludeDirectory;
-    /**
-     * Detect programming language from file extension
-     */
-    private detectLanguage;
-    /**
-     * Read file with LRU cache to reduce repeated file system access
-     */
-    private readFileWithCache;
-    /**
-     * Parse file content to extract code symbols using regex patterns
-     */
-    private parseFileSymbols;
-    /**
-     * Get context lines around a specific line
-     */
-    private getContext;
     /**
      * Check if a directory is a Git repository
      */
     private isGitRepository;
-    /**
-     * Check if a command is available in the system PATH
-     */
-    private isCommandAvailable;
-    /**
-     * Parse grep output (format: filePath:lineNumber:lineContent)
-     */
-    private parseGrepOutput;
     /**
      * Build or refresh the code symbol index with incremental updates
      */
@@ -143,11 +74,6 @@ export declare class ACECodeSearchService {
      * Files modified within last 24 hours are prioritized
      */
     private sortResultsByRecency;
-    /**
-     * Convert glob pattern to RegExp
-     * Supports: *, **, ?, [abc], {js,ts}
-     */
-    private globToRegex;
     /**
      * Get code outline for a file (all symbols in the file)
      */