snow-ai 0.2.14 → 0.2.16

package/dist/mcp/filesystem.js

@@ -3,7 +3,6 @@ import * as path from 'path';
 import { execSync } from 'child_process';
 import { vscodeConnection } from '../utils/vscodeConnection.js';
 import { incrementalSnapshotManager } from '../utils/incrementalSnapshot.js';
-import { multiLanguageASTParser } from './multiLanguageASTParser.js';
 const { resolve, dirname, isAbsolute } = path;
 /**
  * Filesystem MCP Service
@@ -301,26 +300,45 @@ export class FilesystemMCPService {
         }
     }
     /**
-     * Delete a file
-     * @param filePath - Path to the file to delete
-     * @returns Success message
+     * Delete one or multiple files
+     * @param filePaths - Single file path or array of file paths to delete
+     * @returns Success message with details
      * @throws Error if file deletion fails
      */
-    async deleteFile(filePath) {
+    async deleteFile(filePaths) {
         try {
-            const fullPath = this.resolvePath(filePath);
-            await this.validatePath(fullPath);
-            const stats = await fs.stat(fullPath);
-            if (!stats.isFile()) {
-                throw new Error(`Path is not a file: ${filePath}`);
+            const paths = Array.isArray(filePaths) ? filePaths : [filePaths];
+            const results = [];
+            const errors = [];
+            for (const filePath of paths) {
+                try {
+                    const fullPath = this.resolvePath(filePath);
+                    await this.validatePath(fullPath);
+                    const stats = await fs.stat(fullPath);
+                    if (!stats.isFile()) {
+                        throw new Error(`Path is not a file: ${filePath}`);
+                    }
+                    // Backup file before deletion
+                    await incrementalSnapshotManager.backupFile(fullPath);
+                    await fs.unlink(fullPath);
+                    results.push(`✅ ${filePath}`);
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+                    errors.push(`❌ ${filePath}: ${errorMsg}`);
+                }
             }
-            // Backup file before deletion
-            await incrementalSnapshotManager.backupFile(fullPath);
-            await fs.unlink(fullPath);
-            return `File deleted successfully: ${filePath}`;
+            const summary = [];
+            if (results.length > 0) {
+                summary.push(`Successfully deleted ${results.length} file(s):\n${results.join('\n')}`);
+            }
+            if (errors.length > 0) {
+                summary.push(`Failed to delete ${errors.length} file(s):\n${errors.join('\n')}`);
+            }
+            return summary.join('\n\n');
         }
         catch (error) {
-            throw new Error(`Failed to delete file ${filePath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to delete files: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
     /**
@@ -660,37 +678,8 @@ export class FilesystemMCPService {
                         searchedFiles++;
                         try {
                             const content = await fs.readFile(fullPath, 'utf-8');
-                            // AST search mode - supports multiple languages via tree-sitter
-                            if (searchMode === 'ast') {
-                                // Check if file is supported for AST parsing
-                                if (multiLanguageASTParser.isSupported(fullPath)) {
-                                    try {
-                                        const astResults = multiLanguageASTParser.searchAST(content, fullPath, query, caseSensitive);
-                                        for (const result of astResults) {
-                                            if (matches.length >= maxResults) {
-                                                break;
-                                            }
-                                            const lineContent = content.split('\n')[result.startPosition.line - 1] ||
-                                                '';
-                                            matches.push({
-                                                filePath: path.relative(this.basePath, fullPath),
-                                                lineNumber: result.startPosition.line,
-                                                lineContent: lineContent.trim(),
-                                                column: result.startPosition.column,
-                                                matchedText: result.name,
-                                                nodeType: result.type,
-                                                nodeName: result.name,
-                                                language: result.language,
-                                            });
-                                        }
-                                    }
-                                    catch (error) {
-                                        // Skip files with AST parsing errors
-                                    }
-                                }
-                            }
-                            else if (searchRegex) {
-                                // Text or Regex search mode
+                            // Text or Regex search mode
+                            if (searchRegex) {
                                 const lines = content.split('\n');
                                 lines.forEach((line, index) => {
                                     if (matches.length >= maxResults) {
@@ -808,16 +797,32 @@ export const mcpTools = [
     },
     {
         name: 'filesystem_delete',
-        description: 'Delete a file',
+        description: 'Delete one or multiple files. Supports both single file and batch deletion.',
         inputSchema: {
             type: 'object',
             properties: {
                 filePath: {
                     type: 'string',
-                    description: 'Path to the file to delete',
+                    description: 'Path to a single file to delete (deprecated: use filePaths for single or multiple files)',
+                },
+                filePaths: {
+                    oneOf: [
+                        {
+                            type: 'string',
+                            description: 'Path to a single file to delete'
+                        },
+                        {
+                            type: 'array',
+                            items: {
+                                type: 'string'
+                            },
+                            description: 'Array of file paths to delete'
+                        }
+                    ],
+                    description: 'Single file path or array of file paths to delete'
                 },
             },
-            required: ['filePath'],
+            // Make both optional, but at least one is required (validated in code)
         },
     },
     {
@@ -900,8 +905,8 @@ export const mcpTools = [
                 },
                 searchMode: {
                     type: 'string',
-                    enum: ['text', 'regex', 'ast'],
-                    description: 'Search mode: "text" for literal text search (default), "regex" for regular expression search, "ast" for AST-based semantic search (supports function/class/variable names)',
+                    enum: ['text', 'regex'],
+                    description: 'Search mode: "text" for literal text search (default), "regex" for regular expression search',
                     default: 'text',
                 },
             },

package/dist/mcp/todo.js

@@ -192,28 +192,24 @@ Complete TODO list with all task IDs, content, status, and hierarchy.`,
                 name: 'todo-update',
                 description: `Update TODO status or content - USE ONLY WHEN COMPLETING TASKS.
 
-## CORE PRINCIPLE - WORK FIRST, UPDATES LAST:
-Focus on COMPLETING TASKS, not updating status. Only update TODO when a task is 100% finished and verified.
+## CORE PRINCIPLE - WORK FIRST, completed in an orderly manner:
 
-## SIMPLIFIED STATUS MODEL:
+## STATUS MODEL:
 - **pending**: Task not yet completed (default)
 - **completed**: Task is 100% finished and verified
 
 ## WHEN TO UPDATE:
 ✅ **Mark "completed"** ONLY when:
-  - Task is 100% finished (no partial work)
-  - Tests/builds passed (if applicable)
+  - When completing a task in the List
   - No errors or blockers
   - You've actually verified it works
 
 ## WHEN NOT TO UPDATE:
 ❌ Don't update status to track "in progress" - just do the work
-❌ Don't update multiple times per task - once when done is enough
 ❌ Don't update before verifying the work is complete
-❌ Don't update content unless there's a genuine error in the description
 
 ## BEST PRACTICE:
-Complete 3-5 tasks, then batch update them all to "completed" at once. This is more efficient than constant status updates.`,
+Every time you complete a task in Task, it will be updated to "Completed" immediately.`,
                 inputSchema: {
                     type: 'object',
                     properties: {