snow-ai 0.2.23 → 0.2.25

package/dist/cli.js

@@ -7,6 +7,7 @@ import { exec, execSync } from 'child_process';
 import { promisify } from 'util';
 import App from './app.js';
 import { vscodeConnection } from './utils/vscodeConnection.js';
+import { resourceMonitor } from './utils/resourceMonitor.js';
 const execAsync = promisify(exec);
 // Check for updates asynchronously
 async function checkForUpdates(currentVersion) {
@@ -34,6 +35,7 @@ const cli = meow(`
 		--help     Show help
 		--version  Show version
 		--update   Update to latest version
+		-c         Skip welcome screen and resume last conversation
 `, {
     importMeta: import.meta,
     flags: {
@@ -41,6 +43,10 @@ const cli = meow(`
             type: 'boolean',
             default: false,
         },
+        c: {
+            type: 'boolean',
+            default: false,
+        },
     },
 });
 // Handle update flag
@@ -56,8 +62,20 @@ if (cli.flags.update) {
         process.exit(1);
     }
 }
+// Start resource monitoring in development/debug mode
+if (process.env['NODE_ENV'] === 'development' || process.env['DEBUG']) {
+    resourceMonitor.startMonitoring(30000); // Monitor every 30 seconds
+    // Check for leaks every 5 minutes
+    setInterval(() => {
+        const { hasLeak, reasons } = resourceMonitor.checkForLeaks();
+        if (hasLeak) {
+            console.error('⚠️ Potential memory leak detected:');
+            reasons.forEach(reason => console.error(`  - ${reason}`));
+        }
+    }, 5 * 60 * 1000);
+}
 // Startup component that shows loading spinner during update check
-const Startup = ({ version }) => {
+const Startup = ({ version, skipWelcome, }) => {
     const [appReady, setAppReady] = React.useState(false);
     React.useEffect(() => {
         let mounted = true;
@@ -87,13 +105,15 @@ const Startup = ({ version }) => {
                     React.createElement(Spinner, { type: "dots" })),
                 React.createElement(Text, null, " Checking for updates..."))));
     }
-    return React.createElement(App, { version: version });
+    return React.createElement(App, { version: version, skipWelcome: skipWelcome });
 };
 // Disable bracketed paste mode on startup
 process.stdout.write('\x1b[?2004l');
 // Re-enable on exit to avoid polluting parent shell
 const cleanup = () => {
     process.stdout.write('\x1b[?2004l');
+    // Stop resource monitoring
+    resourceMonitor.stopMonitoring();
     // Disconnect VSCode connection before exit
     vscodeConnection.stop();
 };
@@ -106,7 +126,7 @@ process.on('SIGTERM', () => {
     cleanup();
     process.exit(0);
 });
-render(React.createElement(Startup, { version: cli.pkg.version }), {
+render(React.createElement(Startup, { version: cli.pkg.version, skipWelcome: cli.flags.c }), {
     exitOnCtrlC: false,
     patchConsole: true,
 });

package/dist/hooks/useConversation.js

@@ -10,6 +10,7 @@ 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 { resourceMonitor } from '../utils/resourceMonitor.js';
 /**
  * Handle conversation with streaming and tool calls
  */
@@ -64,13 +65,28 @@ export async function handleConversationWithTools(options) {
     }).catch(error => {
         console.error('Failed to save user message:', error);
     });
-    // Initialize token encoder
+    // Initialize token encoder with proper cleanup tracking
     let encoder;
+    let encoderFreed = false;
+    const freeEncoder = () => {
+        if (!encoderFreed && encoder) {
+            try {
+                encoder.free();
+                encoderFreed = true;
+                resourceMonitor.trackEncoderFreed();
+            }
+            catch (e) {
+                console.error('Failed to free encoder:', e);
+            }
+        }
+    };
     try {
         encoder = encoding_for_model('gpt-4');
+        resourceMonitor.trackEncoderCreated();
     }
     catch (e) {
         encoder = encoding_for_model('gpt-3.5-turbo');
+        resourceMonitor.trackEncoderCreated();
     }
     setStreamTokenCount(0);
     const config = getOpenAiConfig();
@@ -83,8 +99,10 @@ export async function handleConversationWithTools(options) {
     const sessionApprovedTools = new Set();
     try {
         while (true) {
-            if (controller.signal.aborted)
+            if (controller.signal.aborted) {
+                freeEncoder();
                 break;
+            }
             let streamedContent = '';
             let receivedToolCalls;
             // Stream AI response - choose API based on config
@@ -200,6 +218,7 @@ export async function handleConversationWithTools(options) {
             // If aborted during streaming, exit the loop
             // (discontinued message already added by ChatScreen ESC handler)
             if (controller.signal.aborted) {
+                freeEncoder();
                 break;
             }
             // If there are tool calls, we need to handle them specially
@@ -222,6 +241,17 @@ export async function handleConversationWithTools(options) {
                 saveMessage(assistantMessage).catch(error => {
                     console.error('Failed to save assistant message:', error);
                 });
+                // If there's text content before tool calls, display it first
+                if (streamedContent && streamedContent.trim()) {
+                    setMessages(prev => [
+                        ...prev,
+                        {
+                            role: 'assistant',
+                            content: streamedContent.trim(),
+                            streaming: false,
+                        },
+                    ]);
+                }
                 // Display tool calls in UI with pending status
                 for (const toolCall of receivedToolCalls) {
                     const toolDisplay = formatToolCallMessage(toolCall);
@@ -292,7 +322,7 @@ export async function handleConversationWithTools(options) {
                         if (options.setIsStreaming) {
                             options.setIsStreaming(false);
                         }
-                        encoder.free();
+                        freeEncoder();
                         return; // Exit the conversation loop
                     }
                     // If approved_always, add ALL these tools to both global and session-approved sets
@@ -307,7 +337,12 @@ export async function handleConversationWithTools(options) {
                     approvedTools.push(...toolsNeedingConfirmation);
                 }
                 // Execute approved tools
-                const toolResults = await executeToolCalls(approvedTools);
+                const toolResults = await executeToolCalls(approvedTools, controller.signal, setStreamTokenCount);
+                // Check if aborted during tool execution
+                if (controller.signal.aborted) {
+                    freeEncoder();
+                    break;
+                }
                 // Check if there are TODO related tool calls, if yes refresh TODO list
                 const hasTodoTools = approvedTools.some(t => t.function.name.startsWith('todo-'));
                 const hasTodoUpdateTools = approvedTools.some(t => t.function.name === 'todo-update');
@@ -367,6 +402,13 @@ export async function handleConversationWithTools(options) {
                                 // If parsing fails, just show regular result
                             }
                         }
+                        // Check if this tool should show preview (websearch, ace, filesystem-read, etc.)
+                        const shouldShowPreview = toolCall.function.name.startsWith('websearch-') ||
+                            toolCall.function.name.startsWith('ace-') ||
+                            toolCall.function.name === 'filesystem-read' ||
+                            toolCall.function.name === 'filesystem-list' ||
+                            toolCall.function.name === 'filesystem-create' ||
+                            toolCall.function.name === 'filesystem-write';
                         // Update the existing pending message instead of adding a new one
                         setMessages(prev => prev.map(msg => {
                             if (msg.toolCallId === toolCall.id && msg.toolPending) {
@@ -384,7 +426,9 @@ export async function handleConversationWithTools(options) {
                                                 name: toolCall.function.name,
                                                 arguments: terminalResultData,
                                             }
-                                            : msg.toolCall,
+                                            : shouldShowPreview
+                                                ? undefined // Clear toolCall for preview-enabled tools
+                                                : msg.toolCall, // Keep original toolCall for other tools
                                     // Store tool result for preview rendering
                                     toolResult: !isError ? result.content : undefined,
                                 };
@@ -464,10 +508,10 @@ export async function handleConversationWithTools(options) {
             break;
         }
         // Free encoder
-        encoder.free();
+        freeEncoder();
     }
     catch (error) {
-        encoder.free();
+        freeEncoder();
         throw error;
     }
 }

package/dist/hooks/useGlobalNavigation.d.ts

@@ -1,6 +1,6 @@
 export declare const NAVIGATION_EVENT = "navigate";
 export interface NavigationEvent {
-    destination: 'welcome' | 'chat' | 'settings' | 'config' | 'models' | 'mcp';
+    destination: 'welcome' | 'chat' | 'settings' | 'mcp' | 'systemprompt' | 'customheaders';
 }
 export declare function navigateTo(destination: NavigationEvent['destination']): void;
 export declare function onNavigate(handler: (event: NavigationEvent) => void): () => void;

package/dist/hooks/useKeyboardInput.js

@@ -26,15 +26,21 @@ export function useKeyboardInput(options) {
     useInput((input, key) => {
         if (disabled)
             return;
-        // Filter out focus events - ONLY if the input is exactly a focus event
-        // Focus events from terminals: ESC[I (focus in) or ESC[O (focus out)
-        // DO NOT filter if input contains other content (like drag-and-drop paths)
-        // The key insight: focus events are standalone, user input is never JUST "[I" or "[O"
-        if (input === '\x1b[I' ||
+        // Filter out focus events more robustly
+        // Focus events: ESC[I (focus in) or ESC[O (focus out)
+        // Some terminals may send these with or without ESC, and they might appear
+        // anywhere in the input string (especially during drag-and-drop with Shift held)
+        // We need to filter them out but NOT remove legitimate user input
+        if (
+        // Complete escape sequences
+        input === '\x1b[I' ||
             input === '\x1b[O' ||
-            // Some terminals may send without ESC, but only if it's the entire input
-            (input === '[I' && input.length === 2) ||
-            (input === '[O' && input.length === 2)) {
+            // Standalone sequences (exact match only)
+            input === '[I' ||
+            input === '[O' ||
+            // Filter if input ONLY contains focus events and whitespace
+            // This handles cases like " [I" or "[I " from drag-and-drop with Shift
+            /^[\s\x1b\[IO]+$/.test(input) && (input.includes('[I') || input.includes('[O'))) {
             return;
         }
         // Shift+Tab - Toggle YOLO mode

package/dist/mcp/filesystem.d.ts

@@ -39,6 +39,26 @@ export declare class FilesystemMCPService {
      */
     private readonly prettierSupportedExtensions;
     constructor(basePath?: string);
+    /**
+     * Calculate similarity between two strings using a smarter algorithm
+     * This normalizes whitespace first to avoid false negatives from spacing differences
+     * Returns a value between 0 (completely different) and 1 (identical)
+     */
+    private calculateSimilarity;
+    /**
+     * Calculate Levenshtein distance between two strings
+     */
+    private levenshteinDistance;
+    /**
+     * Find the closest matching candidates in the file content
+     * Returns top N candidates sorted by similarity
+     */
+    private findClosestMatches;
+    /**
+     * Generate a helpful diff message showing differences between search and actual content
+     * Note: This is ONLY for display purposes. Tabs/spaces are normalized for better readability.
+     */
+    private generateDiffMessage;
     /**
      * Analyze code structure for balance and completeness
      * Helps AI identify bracket mismatches, unclosed tags, and boundary issues
@@ -50,14 +70,14 @@ export declare class FilesystemMCPService {
      */
     private findSmartContextBoundaries;
     /**
-     * Get the content of a file with specified line range
+     * Get the content of a file with optional line range
      * @param filePath - Path to the file (relative to base path or absolute)
-     * @param startLine - Starting line number (1-indexed, inclusive)
-     * @param endLine - Ending line number (1-indexed, inclusive)
+     * @param startLine - Starting line number (1-indexed, inclusive, optional - defaults to 1)
+     * @param endLine - Ending line number (1-indexed, inclusive, optional - defaults to 500 or file end)
      * @returns Object containing the requested content with line numbers and metadata
      * @throws Error if file doesn't exist or cannot be read
      */
-    getFileContent(filePath: string, startLine: number, endLine: number): Promise<{
+    getFileContent(filePath: string, startLine?: number, endLine?: number): Promise<{
         content: string;
         startLine: number;
         endLine: number;
@@ -107,10 +127,10 @@ export declare class FilesystemMCPService {
     }>;
     /**
      * Edit a file by searching for exact content and replacing it
-     * This method is SAFER than line-based editing as it automatically handles code boundaries.
+     * This method uses SMART MATCHING to handle whitespace differences automatically.
      *
      * @param filePath - Path to the file to edit
-     * @param searchContent - Exact content to search for (must match precisely, including whitespace)
+     * @param searchContent - Content to search for (whitespace will be normalized automatically)
      * @param replaceContent - New content to replace the search content with
      * @param occurrence - Which occurrence to replace (1-indexed, default: 1, use -1 for all)
      * @param contextLines - Number of context lines to return before and after the edit (default: 8)
@@ -169,6 +189,29 @@ export declare class FilesystemMCPService {
     private validatePath;
 }
 export declare const filesystemService: FilesystemMCPService;
+/**
+ * MCP Tool definitions for integration
+ *
+ * 🎯 **RECOMMENDED WORKFLOW FOR AI AGENTS**:
+ *
+ * 1️⃣ **SEARCH FIRST** (DON'T skip this!):
+ *    - Use ace_text_search() to find code patterns/strings
+ *    - Use ace_search_symbols() to find functions/classes by name
+ *    - Use ace_file_outline() to understand file structure
+ *
+ * 2️⃣ **READ STRATEGICALLY** (Only after search):
+ *    - Use filesystem_read() WITHOUT line numbers to read entire file
+ *    - OR use filesystem_read(filePath, startLine, endLine) to read specific range
+ *    - ⚠️ AVOID reading files line-by-line from top - wastes tokens!
+ *
+ * 3️⃣ **EDIT SAFELY**:
+ *    - PREFER filesystem_edit_search() for modifying existing code (no line counting!)
+ *    - Use filesystem_edit() only for adding new code or when search-replace doesn't fit
+ *
+ * 📊 **TOKEN EFFICIENCY**:
+ *    - ❌ BAD: Read file top-to-bottom, repeat reading, blind scanning
+ *    - ✅ GOOD: Search → Targeted read → Edit with context
+ */
 export declare const mcpTools: ({
     name: string;
     description: string;