snow-ai 0.2.13 → 0.2.15

package/dist/mcp/filesystem.d.ts

@@ -5,9 +5,6 @@ interface SearchMatch {
     lineContent: string;
     column: number;
     matchedText?: string;
-    nodeType?: string;
-    nodeName?: string;
-    language?: string;
 }
 interface SearchResult {
     query: string;
@@ -151,7 +148,7 @@ export declare class FilesystemMCPService {
      * @param maxResults - Maximum number of results to return (default: 100)
      * @returns Search results with file paths, line numbers, and matched content
      */
-    searchCode(query: string, dirPath?: string, fileExtensions?: string[], caseSensitive?: boolean, maxResults?: number, searchMode?: 'text' | 'regex' | 'ast'): Promise<SearchResult>;
+    searchCode(query: string, dirPath?: string, fileExtensions?: string[], caseSensitive?: boolean, maxResults?: number, searchMode?: 'text' | 'regex'): Promise<SearchResult>;
     /**
      * Resolve path relative to base path and normalize it
      * @private

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
@@ -471,31 +470,39 @@ export class FilesystemMCPService {
             let finalTotalLines = newTotalLines;
             let finalContextEnd = newContextEnd;
             let finalContextContent = newContextContent;
-            try {
-                execSync(`npx prettier --write "${fullPath}"`, {
-                    stdio: 'pipe',
-                    encoding: 'utf-8',
-                });
-                // Re-read the file after formatting to get the formatted content
-                const formattedContent = await fs.readFile(fullPath, 'utf-8');
-                finalLines = formattedContent.split('\n');
-                finalTotalLines = finalLines.length;
-                // Recalculate the context end line based on formatted content
-                finalContextEnd = Math.min(finalTotalLines, contextStart + (newContextEnd - contextStart));
-                // Extract formatted content for context with line numbers
-                const formattedContextLines = finalLines.slice(contextStart - 1, finalContextEnd);
-                finalContextContent = formattedContextLines
-                    .map((line, idx) => {
-                    const lineNum = contextStart + idx;
-                    const paddedNum = String(lineNum).padStart(String(finalContextEnd).length, ' ');
-                    return `${paddedNum}→${line}`;
-                })
-                    .join('\n');
-            }
-            catch (formatError) {
-                // If formatting fails, continue with the original content
-                // This ensures editing is not blocked by formatting issues
-                console.warn(`⚠️  Prettier formatting failed for ${filePath}, returning unformatted content:`, formatError instanceof Error ? formatError.message : 'Unknown error');
+            // Check if Prettier supports this file type
+            const prettierSupportedExtensions = [
+                '.js', '.jsx', '.ts', '.tsx', '.json', '.css', '.scss', '.less',
+                '.html', '.vue', '.yaml', '.yml', '.md', '.graphql', '.gql'
+            ];
+            const fileExtension = path.extname(fullPath).toLowerCase();
+            const shouldFormat = prettierSupportedExtensions.includes(fileExtension);
+            if (shouldFormat) {
+                try {
+                    execSync(`npx prettier --write "${fullPath}"`, {
+                        stdio: 'pipe',
+                        encoding: 'utf-8',
+                    });
+                    // Re-read the file after formatting to get the formatted content
+                    const formattedContent = await fs.readFile(fullPath, 'utf-8');
+                    finalLines = formattedContent.split('\n');
+                    finalTotalLines = finalLines.length;
+                    // Recalculate the context end line based on formatted content
+                    finalContextEnd = Math.min(finalTotalLines, contextStart + (newContextEnd - contextStart));
+                    // Extract formatted content for context with line numbers
+                    const formattedContextLines = finalLines.slice(contextStart - 1, finalContextEnd);
+                    finalContextContent = formattedContextLines
+                        .map((line, idx) => {
+                        const lineNum = contextStart + idx;
+                        const paddedNum = String(lineNum).padStart(String(finalContextEnd).length, ' ');
+                        return `${paddedNum}→${line}`;
+                    })
+                        .join('\n');
+                }
+                catch (formatError) {
+                    // If formatting fails, continue with the original content
+                    // This ensures editing is not blocked by formatting issues
+                }
             }
             // Analyze code structure of the edited content (using formatted content if available)
             const editedContentLines = finalLines.slice(startLine - 1, startLine - 1 + newContentLines.length);
@@ -652,37 +659,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) {
@@ -892,8 +870,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/utils/mcpToolsManager.js

@@ -392,8 +392,8 @@ export async function executeMCPTool(toolName, args) {
             case 'edit':
                 return await filesystemService.editFile(args.filePath, args.startLine, args.endLine, args.newContent, args.contextLines);
             case 'search': {
-                // 兼容性处理：如果 searchMode 不存在或无效，默认使用 'text'
-                const validSearchModes = ['text', 'regex', 'ast'];
+                // 兼容性处理:如果 searchMode 不存在或无效,默认使用 'text'
+                const validSearchModes = ['text', 'regex'];
                 let searchMode = 'text';
                 if (args.searchMode && validSearchModes.includes(args.searchMode)) {
                     searchMode = args.searchMode;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.2.13",
+	"version": "0.2.15",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {
@@ -59,18 +59,6 @@
 		"react": "^18.2.0",
 		"string-width": "^7.2.0",
 		"tiktoken": "^1.0.22",
-		"tree-sitter": "^0.25.0",
-		"tree-sitter-c": "^0.24.1",
-		"tree-sitter-c-sharp": "^0.23.1",
-		"tree-sitter-cpp": "^0.23.4",
-		"tree-sitter-go": "^0.25.0",
-		"tree-sitter-java": "^0.23.5",
-		"tree-sitter-javascript": "^0.25.0",
-		"tree-sitter-php": "^0.24.2",
-		"tree-sitter-python": "^0.25.0",
-		"tree-sitter-ruby": "^0.23.1",
-		"tree-sitter-rust": "^0.24.0",
-		"tree-sitter-typescript": "^0.23.2",
 		"ws": "^8.14.2"
 	},
 	"devDependencies": {

package/readme.md

@@ -57,9 +57,9 @@ $ npm uninstall --global snow-ai
 
 ## Install VSCode Extension
 
-* download [VSIX/snow-cli-0.2.5.vsix](https://github.com/MayDay-wpf/snow-cli/blob/main/VSIX/snow-cli-0.2.5.vsix)
+* download [VSIX/snow-cli-0.2.6.vsix](https://github.com/MayDay-wpf/snow-cli/blob/main/VSIX/snow-cli-0.2.6.vsix)
 
-* open VSCode, click `Extensions` -> `Install from VSIX...` -> select `snow-cli-0.2.5.vsix`
+* open VSCode, click `Extensions` -> `Install from VSIX...` -> select `snow-cli-0.2.6.vsix`
 
 ## Live View
 * **Welcome & Settings**
@@ -73,6 +73,8 @@ $ npm uninstall --global snow-ai
 
 * When mounting: double-click ESC, view the dialogue recorder, select rollback, including file checkpoints
 
+* Windows & MacOS:`ctrl + v` Paste image
+
 * **Commands**
 
 ![alt text](image-2.png)

package/dist/mcp/multiLanguageASTParser.d.ts

@@ -1,67 +0,0 @@
-/**
- * Supported programming languages for AST parsing
- */
-export type SupportedLanguage = 'javascript' | 'typescript' | 'tsx' | 'python' | 'java' | 'go' | 'cpp' | 'c' | 'csharp' | 'rust' | 'ruby' | 'php';
-/**
- * AST node result with metadata
- */
-export interface ASTNodeResult {
-    name: string;
-    type: string;
-    startPosition: {
-        line: number;
-        column: number;
-    };
-    endPosition: {
-        line: number;
-        column: number;
-    };
-    text: string;
-    language: SupportedLanguage;
-}
-/**
- * Multi-language AST parser using tree-sitter
- * Supports JavaScript, TypeScript, Python, Java, Go, C/C++, C#, Rust, Ruby, PHP
- */
-export declare class MultiLanguageASTParser {
-    private parsers;
-    private languageConfigs;
-    constructor();
-    /**
-     * Initialize language configurations
-     */
-    private initializeLanguageConfigs;
-    /**
-     * Initialize parsers for all supported languages
-     */
-    private initializeParsers;
-    /**
-     * Detect language from file extension
-     */
-    detectLanguage(filePath: string): SupportedLanguage | null;
-    /**
-     * Parse source code and search for nodes matching the query
-     */
-    searchAST(sourceCode: string, filePath: string, query: string, caseSensitive?: boolean): ASTNodeResult[];
-    /**
-     * Extract the name/identifier from an AST node based on language
-     */
-    private extractNodeName;
-    /**
-     * Recursively find the first identifier node
-     */
-    private findIdentifier;
-    /**
-     * Get supported file extensions
-     */
-    getSupportedExtensions(): string[];
-    /**
-     * Check if a file is supported for AST parsing
-     */
-    isSupported(filePath: string): boolean;
-    /**
-     * Get node types for a specific language
-     */
-    getNodeTypes(language: SupportedLanguage): string[];
-}
-export declare const multiLanguageASTParser: MultiLanguageASTParser;

package/dist/mcp/multiLanguageASTParser.js

@@ -1,360 +0,0 @@
-import Parser from 'tree-sitter';
-import JavaScript from 'tree-sitter-javascript';
-import TypeScript from 'tree-sitter-typescript';
-import Python from 'tree-sitter-python';
-import Java from 'tree-sitter-java';
-import Go from 'tree-sitter-go';
-import Cpp from 'tree-sitter-cpp';
-import C from 'tree-sitter-c';
-import CSharp from 'tree-sitter-c-sharp';
-import Rust from 'tree-sitter-rust';
-import Ruby from 'tree-sitter-ruby';
-import PHP from 'tree-sitter-php';
-/**
- * Multi-language AST parser using tree-sitter
- * Supports JavaScript, TypeScript, Python, Java, Go, C/C++, C#, Rust, Ruby, PHP
- */
-export class MultiLanguageASTParser {
-    constructor() {
-        Object.defineProperty(this, "parsers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        Object.defineProperty(this, "languageConfigs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        this.initializeLanguageConfigs();
-        this.initializeParsers();
-    }
-    /**
-     * Initialize language configurations
-     */
-    initializeLanguageConfigs() {
-        // JavaScript
-        this.languageConfigs.set('javascript', {
-            extensions: ['.js', '.jsx', '.mjs', '.cjs'],
-            parser: JavaScript,
-            nodeTypes: [
-                'function_declaration',
-                'arrow_function',
-                'function_expression',
-                'class_declaration',
-                'method_definition',
-                'variable_declarator',
-                'lexical_declaration',
-            ],
-        });
-        // TypeScript
-        this.languageConfigs.set('typescript', {
-            extensions: ['.ts'],
-            parser: TypeScript.typescript,
-            nodeTypes: [
-                'function_declaration',
-                'arrow_function',
-                'function_expression',
-                'class_declaration',
-                'method_definition',
-                'interface_declaration',
-                'type_alias_declaration',
-                'enum_declaration',
-                'variable_declarator',
-                'lexical_declaration',
-            ],
-        });
-        // TSX
-        this.languageConfigs.set('tsx', {
-            extensions: ['.tsx'],
-            parser: TypeScript.tsx,
-            nodeTypes: [
-                'function_declaration',
-                'arrow_function',
-                'function_expression',
-                'class_declaration',
-                'method_definition',
-                'interface_declaration',
-                'type_alias_declaration',
-                'enum_declaration',
-                'variable_declarator',
-                'lexical_declaration',
-            ],
-        });
-        // Python
-        this.languageConfigs.set('python', {
-            extensions: ['.py', '.pyw'],
-            parser: Python,
-            nodeTypes: [
-                'function_definition',
-                'class_definition',
-                'decorated_definition',
-                'assignment',
-            ],
-        });
-        // Java
-        this.languageConfigs.set('java', {
-            extensions: ['.java'],
-            parser: Java,
-            nodeTypes: [
-                'method_declaration',
-                'class_declaration',
-                'interface_declaration',
-                'enum_declaration',
-                'constructor_declaration',
-                'field_declaration',
-            ],
-        });
-        // Go
-        this.languageConfigs.set('go', {
-            extensions: ['.go'],
-            parser: Go,
-            nodeTypes: [
-                'function_declaration',
-                'method_declaration',
-                'type_declaration',
-                'type_spec',
-                'var_declaration',
-                'const_declaration',
-            ],
-        });
-        // C++
-        this.languageConfigs.set('cpp', {
-            extensions: ['.cpp', '.cc', '.cxx', '.hpp', '.hxx', '.h'],
-            parser: Cpp,
-            nodeTypes: [
-                'function_definition',
-                'function_declarator',
-                'class_specifier',
-                'struct_specifier',
-                'enum_specifier',
-                'namespace_definition',
-                'declaration',
-            ],
-        });
-        // C
-        this.languageConfigs.set('c', {
-            extensions: ['.c', '.h'],
-            parser: C,
-            nodeTypes: [
-                'function_definition',
-                'function_declarator',
-                'struct_specifier',
-                'enum_specifier',
-                'declaration',
-            ],
-        });
-        // C#
-        this.languageConfigs.set('csharp', {
-            extensions: ['.cs'],
-            parser: CSharp,
-            nodeTypes: [
-                'method_declaration',
-                'class_declaration',
-                'interface_declaration',
-                'struct_declaration',
-                'enum_declaration',
-                'property_declaration',
-                'field_declaration',
-                'constructor_declaration',
-            ],
-        });
-        // Rust
-        this.languageConfigs.set('rust', {
-            extensions: ['.rs'],
-            parser: Rust,
-            nodeTypes: [
-                'function_item',
-                'struct_item',
-                'enum_item',
-                'trait_item',
-                'impl_item',
-                'mod_item',
-                'const_item',
-                'static_item',
-            ],
-        });
-        // Ruby
-        this.languageConfigs.set('ruby', {
-            extensions: ['.rb'],
-            parser: Ruby,
-            nodeTypes: [
-                'method',
-                'singleton_method',
-                'class',
-                'module',
-                'assignment',
-            ],
-        });
-        // PHP
-        this.languageConfigs.set('php', {
-            extensions: ['.php'],
-            parser: PHP.php,
-            nodeTypes: [
-                'function_definition',
-                'method_declaration',
-                'class_declaration',
-                'interface_declaration',
-                'trait_declaration',
-                'property_declaration',
-            ],
-        });
-    }
-    /**
-     * Initialize parsers for all supported languages
-     */
-    initializeParsers() {
-        for (const [language, config] of this.languageConfigs.entries()) {
-            try {
-                const parser = new Parser();
-                parser.setLanguage(config.parser);
-                this.parsers.set(language, parser);
-            }
-            catch (error) {
-                console.error(`Failed to initialize parser for ${language}:`, error instanceof Error ? error.message : 'Unknown error');
-            }
-        }
-    }
-    /**
-     * Detect language from file extension
-     */
-    detectLanguage(filePath) {
-        const ext = filePath.substring(filePath.lastIndexOf('.')).toLowerCase();
-        for (const [language, config] of this.languageConfigs.entries()) {
-            if (config.extensions.includes(ext)) {
-                return language;
-            }
-        }
-        return null;
-    }
-    /**
-     * Parse source code and search for nodes matching the query
-     */
-    searchAST(sourceCode, filePath, query, caseSensitive = false) {
-        const language = this.detectLanguage(filePath);
-        if (!language) {
-            return [];
-        }
-        const parser = this.parsers.get(language);
-        if (!parser) {
-            return [];
-        }
-        try {
-            const tree = parser.parse(sourceCode);
-            const results = [];
-            const searchQuery = caseSensitive ? query : query.toLowerCase();
-            // Traverse the AST
-            const traverse = (node) => {
-                const nodeType = node.type;
-                const config = this.languageConfigs.get(language);
-                // Check if this is a node type we're interested in
-                if (config && config.nodeTypes.includes(nodeType)) {
-                    const nodeName = this.extractNodeName(node, language);
-                    if (nodeName) {
-                        const nameToCheck = caseSensitive
-                            ? nodeName
-                            : nodeName.toLowerCase();
-                        if (nameToCheck.includes(searchQuery)) {
-                            results.push({
-                                name: nodeName,
-                                type: nodeType,
-                                startPosition: {
-                                    line: node.startPosition.row + 1,
-                                    column: node.startPosition.column + 1,
-                                },
-                                endPosition: {
-                                    line: node.endPosition.row + 1,
-                                    column: node.endPosition.column + 1,
-                                },
-                                text: node.text,
-                                language,
-                            });
-                        }
-                    }
-                }
-                // Recursively traverse children
-                for (let i = 0; i < node.childCount; i++) {
-                    const child = node.child(i);
-                    if (child) {
-                        traverse(child);
-                    }
-                }
-            };
-            traverse(tree.rootNode);
-            return results;
-        }
-        catch (error) {
-            console.error(`AST parsing error for ${filePath}:`, error instanceof Error ? error.message : 'Unknown error');
-            return [];
-        }
-    }
-    /**
-     * Extract the name/identifier from an AST node based on language
-     */
-    extractNodeName(node, _language) {
-        // Common patterns for extracting names from different node types
-        const nameFields = ['name', 'identifier', 'declarator', 'property'];
-        for (const field of nameFields) {
-            const nameNode = node.childForFieldName(field);
-            if (nameNode) {
-                // For some languages, we need to go deeper
-                if (nameNode.type === 'identifier') {
-                    return nameNode.text;
-                }
-                // Try to find identifier in children
-                const identifierChild = this.findIdentifier(nameNode);
-                if (identifierChild) {
-                    return identifierChild.text;
-                }
-            }
-        }
-        // Fallback: try to find any identifier child
-        const identifier = this.findIdentifier(node);
-        return identifier ? identifier.text : null;
-    }
-    /**
-     * Recursively find the first identifier node
-     */
-    findIdentifier(node) {
-        if (node.type === 'identifier') {
-            return node;
-        }
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child) {
-                const identifier = this.findIdentifier(child);
-                if (identifier) {
-                    return identifier;
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Get supported file extensions
-     */
-    getSupportedExtensions() {
-        const extensions = [];
-        for (const config of this.languageConfigs.values()) {
-            extensions.push(...config.extensions);
-        }
-        return [...new Set(extensions)];
-    }
-    /**
-     * Check if a file is supported for AST parsing
-     */
-    isSupported(filePath) {
-        return this.detectLanguage(filePath) !== null;
-    }
-    /**
-     * Get node types for a specific language
-     */
-    getNodeTypes(language) {
-        const config = this.languageConfigs.get(language);
-        return config ? config.nodeTypes : [];
-    }
-}
-// Export singleton instance
-export const multiLanguageASTParser = new MultiLanguageASTParser();