snow-ai 0.2.24 → 0.2.26

package/dist/hooks/useTerminalFocus.js

@@ -17,6 +17,10 @@ import { useState, useEffect } from 'react';
  *
  * 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
@@ -27,10 +31,22 @@ export function useTerminalFocus() {
             // 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
@@ -48,10 +64,14 @@ export function useTerminalFocus() {
             process.stdout.write('\x1b[?1004l');
             process.stdin.off('data', handleData);
         };
-    }, []);
+    }, [hasFocus]); // Add hasFocus to dependencies to access current state
     // Helper function to check if input is a focus event
     const isFocusEvent = (input) => {
         return input === '\x1b[I' || input === '\x1b[O';
     };
-    return { hasFocus, isFocusEvent };
+    // Manual focus restoration function (can be called externally if needed)
+    const ensureFocus = () => {
+        setHasFocus(true);
+    };
+    return { hasFocus, isFocusEvent, ensureFocus };
 }

package/dist/mcp/aceCodeSearch.d.ts

@@ -43,7 +43,21 @@ export declare class ACECodeSearchService {
     private indexCache;
     private lastIndexTime;
     private readonly INDEX_CACHE_DURATION;
+    private fzfIndex;
+    private allIndexedFiles;
+    private fileModTimes;
+    private customExcludes;
+    private excludesLoaded;
+    private readonly DEFAULT_EXCLUDES;
     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
      */
@@ -57,13 +71,33 @@ export declare class ACECodeSearchService {
      */
     private getContext;
     /**
-     * Build or refresh the code symbol index
+     * 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
      */
     private buildIndex;
     /**
-     * Search for symbols by name with fuzzy matching
+     * Build fzf index for fast fuzzy symbol name matching
+     */
+    private buildFzfIndex;
+    /**
+     * Search for symbols by name with fuzzy matching using fzf
      */
     searchSymbols(query: string, symbolType?: CodeSymbol['type'], language?: string, maxResults?: number): Promise<SemanticSearchResult>;
+    /**
+     * Fallback symbol search using manual fuzzy matching
+     */
+    private searchSymbolsManual;
     /**
      * Find all references to a symbol
      */
@@ -73,7 +107,22 @@ export declare class ACECodeSearchService {
      */
     findDefinition(symbolName: string, contextFile?: string): Promise<CodeSymbol | null>;
     /**
-     * Fast text search using built-in Node.js (no external dependencies)
+     * Strategy 1: Use git grep for fast searching in Git repositories
+     */
+    private gitGrepSearch;
+    /**
+     * Strategy 2: Use system grep (or ripgrep if available) for fast searching
+     */
+    private systemGrepSearch;
+    /**
+     * Strategy 3: Pure JavaScript fallback search
+     */
+    private jsTextSearch;
+    /**
+     * Fast text search with multi-layer strategy
+     * Strategy 1: git grep (fastest, uses git index)
+     * Strategy 2: system grep/ripgrep (fast, system-optimized)
+     * Strategy 3: JavaScript fallback (slower, but always works)
      * Searches for text patterns across files with glob filtering
      */
     textSearch(pattern: string, fileGlob?: string, isRegex?: boolean, maxResults?: number): Promise<Array<{
@@ -82,6 +131,11 @@ export declare class ACECodeSearchService {
         column: number;
         content: string;
     }>>;
+    /**
+     * Sort search results by file modification time (recent files first)
+     * Files modified within last 24 hours are prioritized
+     */
+    private sortResultsByRecency;
     /**
      * Convert glob pattern to RegExp
      * Supports: *, **, ?, [abc], {js,ts}
@@ -96,7 +150,7 @@ export declare class ACECodeSearchService {
      */
     semanticSearch(query: string, searchType?: 'definition' | 'usage' | 'implementation' | 'all', language?: string, maxResults?: number): Promise<SemanticSearchResult>;
     /**
-     * Clear the symbol index cache
+     * Clear the symbol index cache and force full re-index on next search
      */
     clearCache(): void;
     /**