snow-ai 0.3.35 → 0.3.36

package/dist/api/systemPrompt.js

@@ -141,46 +141,32 @@ PLACEHOLDER_FOR_WORKFLOW_SECTION
 
 ## Available Tools
 
-**Filesystem:**
-- \`filesystem-read\` - Read files before editing
-- \`filesystem-edit\` - Modify existing files
-- \`filesystem-create\` - Create new files
+**Filesystem (SUPPORTS BATCH OPERATIONS):**
+- Read first and then modify to avoid grammatical errors caused by boundary judgment errors**
+
+**BATCH EDITING WORKFLOW - HIGH EFFICIENCY:**
+When modifying multiple files (extremely common in real projects):
+1. Use filesystem-read with array of files to read them ALL at once
+2. Use filesystem-edit or filesystem-edit_search with array config to modify ALL at once
+3. This saves multiple round trips and dramatically improves efficiency
+
+**BATCH EXAMPLES:**
+- Read multiple: \`filesystem-read(filePath=["a.ts", "b.ts", "c.ts"])\`
+- Edit multiple with same change: \`filesystem-edit_search(filePath=["a.ts", "b.ts"], searchContent="old", replaceContent="new")\`
+- Edit multiple with different changes: \`filesystem-edit_search(filePath=[{path:"a.ts", searchContent:"old1", replaceContent:"new1"}, {path:"b.ts", searchContent:"old2", replaceContent:"new2"}])\`
+- Per-file line ranges: \`filesystem-edit(filePath=[{path:"a.ts", startLine:10, endLine:20, newContent:"..."}, {path:"b.ts", startLine:50, endLine:60, newContent:"..."}])\`
+
+**CRITICAL EFFICIENCY RULE:**
+When you need to modify 2+ files, ALWAYS use batch operations instead of calling tools multiple times. This is faster, cleaner, and more reliable.
 
 **Code Search:**
 PLACEHOLDER_FOR_CODE_SEARCH_SECTION
 
 **IDE Diagnostics:**
-- \`ide-get_diagnostics\` - Get real-time diagnostics (errors, warnings, hints) from connected IDE
-  - Supports VSCode and JetBrains IDEs
-  - Returns diagnostic info: severity, line/column, message, source
-  - Requires IDE plugin installed and running
-  - Use AFTER code changes to verify quality
+- After completing all tasks, it is recommended that you use this tool to check the error message in the IDE to avoid missing anything
 
 **Notebook (Code Memory):**
-- \`notebook-add\` - Record fragile code that new features might break during iteration
-  - Core purpose: Prevent new functionality from breaking old functionality
-  - Record: Bugs that recurred, fragile dependencies, critical constraints
-  - Examples: "validateInput() must run first - broke twice", "null return required by X"
-  - **IMPORTANT**: Use notebook for documentation, NOT separate .md files
-- \`notebook-query\` - Manual search (rarely needed, auto-shown when reading files)
-  - Auto-attached: Last 10 notebooks appear when reading ANY file
-  - Use before: Adding features that might affect existing behavior
-- \`notebook-update\` - Update existing note to fix mistakes or refine information
-  - Fix errors in previously recorded notes
-  - Clarify or improve wording after better understanding
-  - Update note when code changes but constraint still applies
-- \`notebook-delete\` - Remove outdated or incorrect notes
-  - Delete when code is refactored and note is obsolete
-  - Remove notes recorded by mistake
-  - Clean up after workarounds are properly fixed
-- \`notebook-list\` - View all notes for a specific file
-  - List all constraints for a file before making changes
-  - Find note IDs for update/delete operations
-  - Review all warnings before refactoring
-
-**Web Search:**
-- \`websearch-search\` - Search web for latest docs/solutions
-- \`websearch-fetch\` - Read web page content (always provide userQuery)
+- Instead of adding md instructions to your project too often, you should use this NoteBook tool for documentation
 
 **Terminal:**
 - \`terminal-execute\` - You have a comprehensive understanding of terminal pipe mechanisms and can help users 
@@ -232,12 +218,7 @@ system administration and data processing challenges.
 
 **PRACTICAL EXAMPLES:**
 
-**BAD - Doing everything in main agent:**
-- User: "Add user authentication"
-- Main: *reads 20 files, analyzes auth patterns, plans implementation, writes code*
-- Result: Main context bloated with analysis that won't be reused
-
-**GOOD - Aggressive delegation:**
+**Best - Aggressive delegation:**
 - User: "Add user authentication"
 - Main: Delegate to sub-agent → "Analyze current auth patterns and create implementation plan"
 - Sub-agent: *analyzes, returns concise plan*
@@ -334,15 +315,23 @@ function getWorkflowSection(hasCodebase) {
     }
     else {
         return `**Your workflow:**
-1. Read the primary file(s) mentioned
+1. Read the primary file(s) mentioned - USE BATCH READ if multiple files
 2. Use \\\`ace-search-symbols\\\`, \\\`ace-find-definition\\\`, or \\\`ace-find-references\\\` to find related code
 3. Check dependencies/imports that directly impact the change
 4. Read related files ONLY if they're critical to understanding the task
-5. Write/modify code with proper context
+5. Write/modify code with proper context - USE BATCH EDIT if modifying 2+ files
 6. Verify with build
 7. NO excessive exploration beyond what's needed
 8. NO reading entire modules "for reference"
-9. NO over-planning multi-step workflows for simple tasks`;
+9. NO over-planning multi-step workflows for simple tasks
+
+**Golden Rule: Read what you need to write correct code, nothing more.**
+
+**BATCH OPERATIONS RULE:**
+When dealing with 2+ files, ALWAYS prefer batch operations:
+- Multiple reads? Use \\\`filesystem-read(filePath=["a.ts", "b.ts"])\\\` in ONE call
+- Multiple edits? Use \\\`filesystem-edit_search(filePath=[{...}, {...}])\\\` in ONE call
+- This is NOT optional for efficiency - batch operations are the EXPECTED workflow`;
     }
 }
 /**

package/dist/hooks/useKeyboardInput.js

@@ -10,6 +10,7 @@ export function useKeyboardInput(options) {
     const inputBuffer = useRef('');
     const inputTimer = useRef(null);
     const isPasting = useRef(false); // Track if we're in pasting mode
+    const inputStartCursorPos = useRef(0); // Track cursor position when input starts accumulating
     // Cleanup timer on unmount
     useEffect(() => {
         return () => {
@@ -374,6 +375,22 @@ export function useKeyboardInput(options) {
         }
         // Arrow keys for cursor movement
         if (key.leftArrow) {
+            // If there's accumulated input, process it immediately before moving cursor
+            if (inputBuffer.current) {
+                if (inputTimer.current) {
+                    clearTimeout(inputTimer.current);
+                    inputTimer.current = null;
+                }
+                const accumulated = inputBuffer.current;
+                const savedCursorPosition = inputStartCursorPos.current;
+                inputBuffer.current = '';
+                isPasting.current = false;
+                // Insert at saved position
+                buffer.setCursorPosition(savedCursorPosition);
+                buffer.insert(accumulated);
+                // Reset inputStartCursorPos after processing
+                inputStartCursorPos.current = buffer.getCursorPosition();
+            }
             buffer.moveLeft();
             const text = buffer.getFullText();
             const cursorPos = buffer.getCursorPosition();
@@ -382,6 +399,22 @@ export function useKeyboardInput(options) {
             return;
         }
         if (key.rightArrow) {
+            // If there's accumulated input, process it immediately before moving cursor
+            if (inputBuffer.current) {
+                if (inputTimer.current) {
+                    clearTimeout(inputTimer.current);
+                    inputTimer.current = null;
+                }
+                const accumulated = inputBuffer.current;
+                const savedCursorPosition = inputStartCursorPos.current;
+                inputBuffer.current = '';
+                isPasting.current = false;
+                // Insert at saved position
+                buffer.setCursorPosition(savedCursorPosition);
+                buffer.insert(accumulated);
+                // Reset inputStartCursorPos after processing
+                inputStartCursorPos.current = buffer.getCursorPosition();
+            }
             buffer.moveRight();
             const text = buffer.getFullText();
             const cursorPos = buffer.getCursorPosition();
@@ -390,6 +423,22 @@ export function useKeyboardInput(options) {
             return;
         }
         if (key.upArrow && !showCommands && !showFilePicker) {
+            // If there's accumulated input, process it immediately before moving cursor
+            if (inputBuffer.current) {
+                if (inputTimer.current) {
+                    clearTimeout(inputTimer.current);
+                    inputTimer.current = null;
+                }
+                const accumulated = inputBuffer.current;
+                const savedCursorPosition = inputStartCursorPos.current;
+                inputBuffer.current = '';
+                isPasting.current = false;
+                // Insert at saved position
+                buffer.setCursorPosition(savedCursorPosition);
+                buffer.insert(accumulated);
+                // Reset inputStartCursorPos after processing
+                inputStartCursorPos.current = buffer.getCursorPosition();
+            }
             const text = buffer.getFullText();
             const cursorPos = buffer.getCursorPosition();
             const isEmpty = text.trim() === '';
@@ -414,6 +463,22 @@ export function useKeyboardInput(options) {
             return;
         }
         if (key.downArrow && !showCommands && !showFilePicker) {
+            // If there's accumulated input, process it immediately before moving cursor
+            if (inputBuffer.current) {
+                if (inputTimer.current) {
+                    clearTimeout(inputTimer.current);
+                    inputTimer.current = null;
+                }
+                const accumulated = inputBuffer.current;
+                const savedCursorPosition = inputStartCursorPos.current;
+                inputBuffer.current = '';
+                isPasting.current = false;
+                // Insert at saved position
+                buffer.setCursorPosition(savedCursorPosition);
+                buffer.insert(accumulated);
+                // Reset inputStartCursorPos after processing
+                inputStartCursorPos.current = buffer.getCursorPosition();
+            }
             const text = buffer.getFullText();
             const cursorPos = buffer.getCursorPosition();
             const isEmpty = text.trim() === '';
@@ -447,44 +512,85 @@ export function useKeyboardInput(options) {
             // This is especially important for drag-and-drop operations where focus
             // events may arrive out of order or be filtered by sanitizeInput
             ensureFocus();
-            // Accumulate input for paste detection
-            inputBuffer.current += input;
-            // Clear existing timer
-            if (inputTimer.current) {
-                clearTimeout(inputTimer.current);
-            }
-            // Detect large paste: if accumulated buffer is getting large, extend timeout
-            // This prevents splitting large pastes into multiple insert() calls
-            const currentLength = inputBuffer.current.length;
-            const timeoutDelay = currentLength > 200 ? 150 : 10;
-            // Show pasting indicator for large text (>300 chars)
-            // Simple static message - no progress animation
-            if (currentLength > 300 && !isPasting.current) {
-                isPasting.current = true;
-                buffer.insertPastingIndicator();
-                // Trigger UI update to show the indicator
+            // Detect if this is a single character input (normal typing) or multi-character (paste)
+            const isSingleCharInput = input.length === 1;
+            if (isSingleCharInput) {
+                // For single character input (normal typing), insert immediately
+                // This prevents the "disappearing text" issue at line start
+                buffer.insert(input);
                 const text = buffer.getFullText();
                 const cursorPos = buffer.getCursorPosition();
                 updateCommandPanelState(text);
                 updateFilePickerState(text, cursorPos);
                 triggerUpdate();
             }
-            // Set timer to process accumulated input
-            inputTimer.current = setTimeout(() => {
-                const accumulated = inputBuffer.current;
-                inputBuffer.current = '';
-                isPasting.current = false; // Reset pasting state
-                // If we accumulated input, insert it as a single operation
-                // The insert() method will automatically remove the pasting indicator
-                if (accumulated) {
-                    buffer.insert(accumulated);
+            else {
+                // For multi-character input (paste), use the buffering mechanism
+                // Save cursor position when starting new input accumulation
+                const isStartingNewInput = inputBuffer.current === '';
+                if (isStartingNewInput) {
+                    inputStartCursorPos.current = buffer.getCursorPosition();
+                }
+                // Accumulate input for paste detection
+                inputBuffer.current += input;
+                // Clear existing timer
+                if (inputTimer.current) {
+                    clearTimeout(inputTimer.current);
+                }
+                // Detect large paste: if accumulated buffer is getting large, extend timeout
+                // This prevents splitting large pastes into multiple insert() calls
+                const currentLength = inputBuffer.current.length;
+                const timeoutDelay = currentLength > 200 ? 150 : 10;
+                // Show pasting indicator for large text (>300 chars)
+                // Simple static message - no progress animation
+                if (currentLength > 300 && !isPasting.current) {
+                    isPasting.current = true;
+                    buffer.insertPastingIndicator();
+                    // Trigger UI update to show the indicator
                     const text = buffer.getFullText();
                     const cursorPos = buffer.getCursorPosition();
                     updateCommandPanelState(text);
                     updateFilePickerState(text, cursorPos);
                     triggerUpdate();
                 }
-            }, timeoutDelay); // Extended delay for large pastes to ensure complete accumulation
+                // Set timer to process accumulated input
+                inputTimer.current = setTimeout(() => {
+                    const accumulated = inputBuffer.current;
+                    const savedCursorPosition = inputStartCursorPos.current;
+                    const wasPasting = isPasting.current; // Save pasting state before clearing
+                    inputBuffer.current = '';
+                    isPasting.current = false; // Reset pasting state
+                    // If we accumulated input, insert it at the saved cursor position
+                    // The insert() method will automatically remove the pasting indicator
+                    if (accumulated) {
+                        // Get current cursor position to calculate if user moved cursor during input
+                        const currentCursor = buffer.getCursorPosition();
+                        // If cursor hasn't moved from where we started (or only moved due to pasting indicator),
+                        // insert at the saved position
+                        // Otherwise, insert at current position (user deliberately moved cursor)
+                        // Note: wasPasting check uses saved state, not current isPasting.current
+                        if (currentCursor === savedCursorPosition ||
+                            (wasPasting && currentCursor > savedCursorPosition)) {
+                            // Temporarily set cursor to saved position for insertion
+                            // This is safe because we're in a timeout, not during active cursor movement
+                            buffer.setCursorPosition(savedCursorPosition);
+                            buffer.insert(accumulated);
+                            // No need to restore cursor - insert() moves it naturally
+                        }
+                        else {
+                            // User moved cursor during input, insert at current position
+                            buffer.insert(accumulated);
+                        }
+                        // Reset inputStartCursorPos after processing to prevent stale position
+                        inputStartCursorPos.current = buffer.getCursorPosition();
+                        const text = buffer.getFullText();
+                        const cursorPos = buffer.getCursorPosition();
+                        updateCommandPanelState(text);
+                        updateFilePickerState(text, cursorPos);
+                        triggerUpdate();
+                    }
+                }, timeoutDelay); // Extended delay for large pastes to ensure complete accumulation
+            }
         }
     });
 }

package/dist/mcp/aceCodeSearch.d.ts

@@ -56,6 +56,11 @@ export declare class ACECodeSearchService {
      * Strategy 2: Use system grep (or ripgrep if available) for fast searching
      */
     private systemGrepSearch;
+    /**
+     * Convert a glob pattern to a RegExp that matches full paths
+     * Supports: *, **, ?, {a,b}, [abc]
+     */
+    private globPatternToRegex;
     /**
      * Strategy 3: Pure JavaScript fallback search
      */
@@ -76,6 +81,7 @@ export declare class ACECodeSearchService {
     /**
      * Sort search results by file modification time (recent files first)
      * Files modified within last 24 hours are prioritized
+     * Uses parallel stat calls for better performance
      */
     private sortResultsByRecency;
     /**

package/dist/mcp/aceCodeSearch.js

@@ -7,7 +7,7 @@ import { processManager } from '../utils/processManager.js';
 import { detectLanguage } from './utils/aceCodeSearch/language.utils.js';
 import { loadExclusionPatterns, shouldExcludeDirectory, readFileWithCache, } from './utils/aceCodeSearch/filesystem.utils.js';
 import { parseFileSymbols, getContext, } from './utils/aceCodeSearch/symbol.utils.js';
-import { isCommandAvailable, parseGrepOutput, globToRegex, } from './utils/aceCodeSearch/search.utils.js';
+import { isCommandAvailable, parseGrepOutput, } from './utils/aceCodeSearch/search.utils.js';
 export class ACECodeSearchService {
     constructor(basePath = process.cwd()) {
         Object.defineProperty(this, "basePath", {
@@ -196,10 +196,11 @@ export class ACECodeSearchService {
                 await fs.access(cachedPath);
             }
             catch {
-                // File no longer exists, remove from cache
+                // File no longer exists, remove from all caches
                 this.indexCache.delete(cachedPath);
                 this.fileModTimes.delete(cachedPath);
                 this.allIndexedFiles.delete(cachedPath);
+                this.fileContentCache.delete(cachedPath);
             }
         }
         this.lastIndexTime = now;
@@ -372,6 +373,10 @@ export class ACECodeSearchService {
      */
     async findReferences(symbolName, maxResults = 100) {
         const references = [];
+        // Load exclusion patterns
+        await this.loadExclusionPatterns();
+        // Escape special regex characters to prevent ReDoS
+        const escapedSymbol = symbolName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         const searchInDirectory = async (dirPath) => {
             try {
                 const entries = await fs.readdir(dirPath, { withFileTypes: true });
@@ -380,11 +385,8 @@ export class ACECodeSearchService {
                         break;
                     const fullPath = path.join(dirPath, entry.name);
                     if (entry.isDirectory()) {
-                        if (entry.name === 'node_modules' ||
-                            entry.name === '.git' ||
-                            entry.name === 'dist' ||
-                            entry.name === 'build' ||
-                            entry.name.startsWith('.')) {
+                        // Use configurable exclusion check
+                        if (shouldExcludeDirectory(entry.name, fullPath, this.basePath, this.customExcludes, this.regexCache)) {
                             continue;
                         }
                         await searchInDirectory(fullPath);
@@ -395,12 +397,14 @@ export class ACECodeSearchService {
                             try {
                                 const content = await fs.readFile(fullPath, 'utf-8');
                                 const lines = content.split('\n');
-                                // Search for symbol usage
+                                // Search for symbol usage with escaped symbol name
+                                const regex = new RegExp(`\\b${escapedSymbol}\\b`, 'g');
                                 for (let i = 0; i < lines.length; i++) {
                                     const line = lines[i];
                                     if (!line)
                                         continue;
-                                    const regex = new RegExp(`\\b${symbolName}\\b`, 'g');
+                                    // Reset regex for each line
+                                    regex.lastIndex = 0;
                                     let match;
                                     while ((match = regex.exec(line)) !== null) {
                                         if (references.length >= maxResults)
@@ -410,7 +414,7 @@ export class ACECodeSearchService {
                                         if (line.includes('import') && line.includes(symbolName)) {
                                             referenceType = 'import';
                                         }
-                                        else if (line.match(new RegExp(`(?:function|class|const|let|var)\\s+${symbolName}`))) {
+                                        else if (new RegExp(`(?:function|class|const|let|var)\\s+${escapedSymbol}`).test(line)) {
                                             referenceType = 'definition';
                                         }
                                         else if (line.includes(':') &&
@@ -491,19 +495,24 @@ export class ACECodeSearchService {
     /**
      * Strategy 1: Use git grep for fast searching in Git repositories
      */
-    async gitGrepSearch(pattern, fileGlob, maxResults = 100) {
+    async gitGrepSearch(pattern, fileGlob, maxResults = 100, isRegex = false) {
         return new Promise((resolve, reject) => {
-            const args = [
-                'grep',
-                '--untracked',
-                '-n',
-                '-E',
-                '--ignore-case',
-                pattern,
-            ];
+            const args = ['grep', '--untracked', '-n', '--ignore-case'];
+            // Use fixed-strings for literal search, extended regex for pattern search
+            if (isRegex) {
+                args.push('-E'); // Extended regex
+            }
+            else {
+                args.push('--fixed-strings'); // Literal string matching
+            }
+            args.push(pattern);
             if (fileGlob) {
-                // Expand glob patterns with braces (e.g., "source/**/*.{ts,tsx}" -> ["source/**/*.ts", "source/**/*.tsx"])
-                const expandedGlobs = this.expandGlobBraces(fileGlob);
+                // Normalize path separators for Windows compatibility
+                let gitGlob = fileGlob.replace(/\\/g, '/');
+                // Convert ** to * as git grep has limited ** support
+                gitGlob = gitGlob.replace(/\*\*/g, '*');
+                // Expand glob patterns with braces (e.g., "source/*.{ts,tsx}" -> ["source/*.ts", "source/*.tsx"])
+                const expandedGlobs = this.expandGlobBraces(gitGlob);
                 args.push('--', ...expandedGlobs);
             }
             const child = spawn('git', args, {
@@ -563,14 +572,22 @@ export class ACECodeSearchService {
                 // Ripgrep uses --glob for filtering
                 excludeDirs.forEach(dir => args.push('--glob', `!${dir}/`));
                 if (fileGlob) {
-                    args.push('--glob', fileGlob);
+                    // Normalize path separators for Windows compatibility
+                    const normalizedGlob = fileGlob.replace(/\\/g, '/');
+                    // Expand glob patterns with braces
+                    const expandedGlobs = this.expandGlobBraces(normalizedGlob);
+                    expandedGlobs.forEach(glob => args.push('--glob', glob));
                 }
             }
             else {
                 // System grep uses --exclude-dir
                 excludeDirs.forEach(dir => args.push(`--exclude-dir=${dir}`));
                 if (fileGlob) {
-                    args.push(`--include=${fileGlob}`);
+                    // Normalize path separators for Windows compatibility
+                    const normalizedGlob = fileGlob.replace(/\\/g, '/');
+                    // Expand glob patterns with braces
+                    const expandedGlobs = this.expandGlobBraces(normalizedGlob);
+                    expandedGlobs.forEach(glob => args.push(`--include=${glob}`));
                 }
                 args.push(pattern, '.');
             }
@@ -615,11 +632,35 @@ export class ACECodeSearchService {
             });
         });
     }
+    /**
+     * Convert a glob pattern to a RegExp that matches full paths
+     * Supports: *, **, ?, {a,b}, [abc]
+     */
+    globPatternToRegex(globPattern) {
+        // Normalize path separators
+        const normalizedGlob = globPattern.replace(/\\/g, '/');
+        // First, temporarily replace glob special patterns with placeholders
+        // to prevent them from being escaped
+        let regexStr = normalizedGlob
+            .replace(/\*\*/g, '\x00DOUBLESTAR\x00') // ** -> placeholder
+            .replace(/\*/g, '\x00STAR\x00') // * -> placeholder
+            .replace(/\?/g, '\x00QUESTION\x00'); // ? -> placeholder
+        // Now escape all special regex characters
+        regexStr = regexStr.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        // Replace placeholders with actual regex patterns
+        regexStr = regexStr
+            .replace(/\x00DOUBLESTAR\x00/g, '.*') // ** -> .* (match any path segments)
+            .replace(/\x00STAR\x00/g, '[^/]*') // * -> [^/]* (match within single segment)
+            .replace(/\x00QUESTION\x00/g, '.'); // ? -> . (match single character)
+        return new RegExp(regexStr, 'i');
+    }
     /**
      * Strategy 3: Pure JavaScript fallback search
      */
     async jsTextSearch(pattern, fileGlob, isRegex = false, maxResults = 100) {
         const results = [];
+        // Load exclusion patterns
+        await this.loadExclusionPatterns();
         // Compile search pattern
         let searchRegex;
         try {
@@ -635,8 +676,42 @@ export class ACECodeSearchService {
         catch (error) {
             throw new Error(`Invalid regex pattern: ${pattern}`);
         }
-        // Parse glob pattern if provided
-        const globRegex = fileGlob ? globToRegex(fileGlob) : null;
+        // Parse glob pattern if provided using improved glob parser
+        const globRegex = fileGlob ? this.globPatternToRegex(fileGlob) : null;
+        // Binary file extensions (using Set for O(1) lookup)
+        const binaryExts = new Set([
+            '.jpg',
+            '.jpeg',
+            '.png',
+            '.gif',
+            '.bmp',
+            '.ico',
+            '.svg',
+            '.pdf',
+            '.zip',
+            '.tar',
+            '.gz',
+            '.rar',
+            '.7z',
+            '.exe',
+            '.dll',
+            '.so',
+            '.dylib',
+            '.mp3',
+            '.mp4',
+            '.avi',
+            '.mov',
+            '.woff',
+            '.woff2',
+            '.ttf',
+            '.eot',
+            '.class',
+            '.jar',
+            '.war',
+            '.o',
+            '.a',
+            '.lib',
+        ]);
         // Search recursively
         const searchInDirectory = async (dirPath) => {
             if (results.length >= maxResults)
@@ -648,62 +723,26 @@ export class ACECodeSearchService {
                         break;
                     const fullPath = path.join(dirPath, entry.name);
                     if (entry.isDirectory()) {
-                        // Skip ignored directories
-                        if (entry.name === 'node_modules' ||
-                            entry.name === '.git' ||
-                            entry.name === 'dist' ||
-                            entry.name === 'build' ||
-                            entry.name === '__pycache__' ||
-                            entry.name === 'target' ||
-                            entry.name === '.next' ||
-                            entry.name === '.nuxt' ||
-                            entry.name === 'coverage' ||
-                            entry.name.startsWith('.')) {
+                        // Use configurable exclusion check
+                        if (shouldExcludeDirectory(entry.name, fullPath, this.basePath, this.customExcludes, this.regexCache)) {
                             continue;
                         }
                         await searchInDirectory(fullPath);
                     }
                     else if (entry.isFile()) {
                         // Filter by glob if specified
-                        if (globRegex && !globRegex.test(fullPath)) {
-                            continue;
+                        if (globRegex) {
+                            // Use relative path from basePath for glob matching
+                            const relativePath = path
+                                .relative(this.basePath, fullPath)
+                                .replace(/\\/g, '/');
+                            if (!globRegex.test(relativePath)) {
+                                continue;
+                            }
                         }
-                        // Skip binary files
+                        // Skip binary files (using Set for fast lookup)
                         const ext = path.extname(entry.name).toLowerCase();
-                        const binaryExts = [
-                            '.jpg',
-                            '.jpeg',
-                            '.png',
-                            '.gif',
-                            '.bmp',
-                            '.ico',
-                            '.svg',
-                            '.pdf',
-                            '.zip',
-                            '.tar',
-                            '.gz',
-                            '.rar',
-                            '.7z',
-                            '.exe',
-                            '.dll',
-                            '.so',
-                            '.dylib',
-                            '.mp3',
-                            '.mp4',
-                            '.avi',
-                            '.mov',
-                            '.woff',
-                            '.woff2',
-                            '.ttf',
-                            '.eot',
-                            '.class',
-                            '.jar',
-                            '.war',
-                            '.o',
-                            '.a',
-                            '.lib',
-                        ];
-                        if (binaryExts.includes(ext)) {
+                        if (binaryExts.has(ext)) {
                             continue;
                         }
                         try {
@@ -754,10 +793,8 @@ export class ACECodeSearchService {
             try {
                 const gitAvailable = await isCommandAvailable('git');
                 if (gitAvailable) {
-                    const results = await this.gitGrepSearch(pattern, fileGlob, maxResults);
-                    if (results.length > 0 || !isRegex) {
-                        // git grep doesn't support all regex features,
-                        // fall back if pattern is complex regex and no results
+                    const results = await this.gitGrepSearch(pattern, fileGlob, maxResults, isRegex);
+                    if (results.length > 0) {
                         return await this.sortResultsByRecency(results);
                     }
                 }
@@ -786,27 +823,32 @@ export class ACECodeSearchService {
     /**
      * Sort search results by file modification time (recent files first)
      * Files modified within last 24 hours are prioritized
+     * Uses parallel stat calls for better performance
      */
     async sortResultsByRecency(results) {
         if (results.length === 0)
             return results;
         const now = Date.now();
         const recentThreshold = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
-        // Get file modification times
+        // Get unique file paths
+        const uniqueFiles = Array.from(new Set(results.map(r => r.filePath)));
+        // Fetch file modification times in parallel using Promise.allSettled
+        const statResults = await Promise.allSettled(uniqueFiles.map(async (filePath) => {
+            const fullPath = path.resolve(this.basePath, filePath);
+            const stats = await fs.stat(fullPath);
+            return { filePath, mtimeMs: stats.mtimeMs };
+        }));
+        // Build map of file modification times
         const fileModTimes = new Map();
-        for (const result of results) {
-            if (fileModTimes.has(result.filePath))
-                continue;
-            try {
-                const fullPath = path.resolve(this.basePath, result.filePath);
-                const stats = await fs.stat(fullPath);
-                fileModTimes.set(result.filePath, stats.mtimeMs);
+        statResults.forEach((result, index) => {
+            if (result.status === 'fulfilled') {
+                fileModTimes.set(result.value.filePath, result.value.mtimeMs);
             }
-            catch {
+            else {
                 // If we can't get stats, treat as old file
-                fileModTimes.set(result.filePath, 0);
+                fileModTimes.set(uniqueFiles[index], 0);
             }
-        }
+        });
         // Sort results: recent files first, then by original order
         return results.sort((a, b) => {
             const aMtime = fileModTimes.get(a.filePath) || 0;

package/dist/ui/components/ChatInput.js

@@ -1,6 +1,6 @@
 import React, { useCallback, useEffect, useRef, useMemo } from 'react';
 import { Box, Text } from 'ink';
-import { cpSlice, cpLen } from '../../utils/textUtils.js';
+import { cpSlice } from '../../utils/textUtils.js';
 import CommandPanel from './CommandPanel.js';
 import FileList from './FileList.js';
 import AgentPickerPanel from './AgentPickerPanel.js';
@@ -211,36 +211,28 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
         }
     }, [hasFocus]);
     // Render content with cursor (treat all text including placeholders as plain text)
-    const renderContent = useCallback(() => {
+    const renderContent = () => {
         if (buffer.text.length > 0) {
-            // 使用buffer的内部文本,将占位符当作普通文本处理
-            const displayText = buffer.text;
-            const cursorPos = buffer.getCursorPosition();
-            const charInfo = buffer.getCharAtCursor();
-            const atCursor = charInfo.char === '\n' ? ' ' : charInfo.char;
-            // Split text into lines for proper multi-line rendering
-            const lines = displayText.split('\n');
+            // Use visual lines for proper wrapping and multi-line support
+            const visualLines = buffer.viewportVisualLines;
+            const [cursorRow, cursorCol] = buffer.visualCursor;
             const renderedLines = [];
-            let currentPos = 0;
-            for (let i = 0; i < lines.length; i++) {
-                const line = lines[i] || '';
-                const lineStart = currentPos;
-                const lineEnd = lineStart + cpLen(line);
-                // Check if cursor is in this line
-                if (cursorPos >= lineStart && cursorPos <= lineEnd) {
-                    const beforeCursor = cpSlice(line, 0, cursorPos - lineStart);
-                    const afterCursor = cpSlice(line, cursorPos - lineStart + 1);
-                    renderedLines.push(React.createElement(Text, { key: i },
-                        beforeCursor,
+            for (let i = 0; i < visualLines.length; i++) {
+                const line = visualLines[i] || '';
+                if (i === cursorRow) {
+                    // This line contains the cursor
+                    const beforeCursor = cpSlice(line, 0, cursorCol);
+                    const atCursor = cpSlice(line, cursorCol, cursorCol + 1) || ' ';
+                    const afterCursor = cpSlice(line, cursorCol + 1);
+                    renderedLines.push(React.createElement(Box, { key: i, flexDirection: "row" },
+                        React.createElement(Text, null, beforeCursor),
                         renderCursor(atCursor),
-                        afterCursor));
+                        React.createElement(Text, null, afterCursor)));
                 }
                 else {
                     // No cursor in this line
                     renderedLines.push(React.createElement(Text, { key: i }, line || ' '));
                 }
-                // Account for newline character
-                currentPos = lineEnd + 1;
             }
             return React.createElement(Box, { flexDirection: "column" }, renderedLines);
         }
@@ -249,7 +241,7 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
                 renderCursor(' '),
                 React.createElement(Text, { color: disabled ? 'darkGray' : 'gray', dimColor: true }, disabled ? 'Waiting for response...' : placeholder)));
         }
-    }, [buffer, disabled, placeholder, renderCursor]); // 移除 buffer.text 避免循环依赖，buffer 变化时会自然触发重渲染
+    };
     return (React.createElement(Box, { flexDirection: "column", paddingX: 1, width: terminalWidth },
         showHistoryMenu && (React.createElement(Box, { flexDirection: "column", marginBottom: 1, width: terminalWidth - 2 },
             React.createElement(Box, { flexDirection: "column" }, (() => {

package/dist/utils/textBuffer.d.ts

@@ -50,6 +50,7 @@ export declare class TextBuffer {
     getFullText(): string;
     get visualCursor(): [number, number];
     getCursorPosition(): number;
+    setCursorPosition(position: number): void;
     get viewportVisualLines(): string[];
     get maxWidth(): number;
     private scheduleUpdate;

package/dist/utils/textBuffer.js

@@ -131,6 +131,11 @@ export class TextBuffer {
     getCursorPosition() {
         return this.cursorIndex;
     }
+    setCursorPosition(position) {
+        this.cursorIndex = position;
+        this.clampCursorIndex();
+        this.recomputeVisualCursorOnly();
+    }
     get viewportVisualLines() {
         return this.visualLines;
     }
@@ -161,9 +166,21 @@ export class TextBuffer {
             return;
         }
         const charCount = sanitized.length;
-        // 如果存在临时"粘贴中"占位符，先移除它
+        // 如果存在临时"粘贴中"占位符，先移除它，并调整光标位置
         if (this.tempPastingPlaceholder) {
-            this.content = this.content.replace(this.tempPastingPlaceholder, '');
+            const placeholderIndex = this.content.indexOf(this.tempPastingPlaceholder);
+            if (placeholderIndex !== -1) {
+                // 找到占位符的位置
+                const placeholderLength = cpLen(this.tempPastingPlaceholder);
+                // 移除占位符
+                this.content =
+                    this.content.slice(0, placeholderIndex) +
+                        this.content.slice(placeholderIndex + this.tempPastingPlaceholder.length);
+                // 调整光标位置:如果光标在占位符之后,需要向前移动
+                if (this.cursorIndex > placeholderIndex) {
+                    this.cursorIndex = Math.max(placeholderIndex, this.cursorIndex - placeholderLength);
+                }
+            }
             this.tempPastingPlaceholder = null;
         }
         // 如果是大文本（>300字符），直接创建占位符
@@ -364,11 +381,59 @@ export class TextBuffer {
         const codePoints = toCodePoints(line);
         const segments = [];
         let start = 0;
+        // Helper function to find placeholder at given position
+        const findPlaceholderAt = (pos) => {
+            // Look backwards to find the opening bracket
+            let openPos = pos;
+            while (openPos >= 0 && codePoints[openPos] !== '[') {
+                openPos--;
+            }
+            if (openPos >= 0 && codePoints[openPos] === '[') {
+                // Look forward to find the closing bracket
+                let closePos = openPos + 1;
+                while (closePos < codePoints.length && codePoints[closePos] !== ']') {
+                    closePos++;
+                }
+                if (closePos < codePoints.length && codePoints[closePos] === ']') {
+                    const placeholderText = codePoints.slice(openPos, closePos + 1).join('');
+                    // Check if it's a valid placeholder
+                    if (placeholderText.match(/^\[Paste \d+ lines #\d+\]$/) ||
+                        placeholderText.match(/^\[image #\d+\]$/) ||
+                        placeholderText === '[Pasting...]') {
+                        return { start: openPos, end: closePos + 1 };
+                    }
+                }
+            }
+            return null;
+        };
         while (start < codePoints.length) {
             let currentWidth = 0;
             let end = start;
             let lastBreak = -1;
             while (end < codePoints.length) {
+                // Check if current position is start of a placeholder
+                if (codePoints[end] === '[') {
+                    const placeholder = findPlaceholderAt(end);
+                    if (placeholder && placeholder.start === end) {
+                        const placeholderText = codePoints.slice(placeholder.start, placeholder.end).join('');
+                        const placeholderWidth = Array.from(placeholderText).reduce((sum, c) => sum + visualWidth(c), 0);
+                        // If placeholder fits on current line, include it
+                        if (currentWidth + placeholderWidth <= width) {
+                            currentWidth += placeholderWidth;
+                            end = placeholder.end;
+                            continue;
+                        }
+                        else if (currentWidth === 0) {
+                            // Placeholder doesn't fit but we're at line start, force it on this line
+                            end = placeholder.end;
+                            break;
+                        }
+                        else {
+                            // Placeholder doesn't fit, break before it
+                            break;
+                        }
+                    }
+                }
                 const char = codePoints[end] || '';
                 const charWidth = visualWidth(char);
                 if (char === ' ') {
@@ -452,8 +517,8 @@ export class TextBuffer {
      */
     getImages() {
         return Array.from(this.placeholderStorage.values())
-            .filter((p) => p.type === 'image')
-            .map((p) => {
+            .filter(p => p.type === 'image')
+            .map(p => {
             const mimeType = p.mimeType || 'image/png';
             // 还原为 data URL 格式
             const dataUrl = `data:${mimeType};base64,${p.content}`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.3.35",
+	"version": "0.3.36",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {