snow-ai 0.2.12 → 0.2.13

package/dist/mcp/multiLanguageASTParser.js

@@ -0,0 +1,360 @@
+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();

package/dist/mcp/todo.d.ts

@@ -2,7 +2,7 @@ import { Tool, type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 interface TodoItem {
     id: string;
     content: string;
-    status: 'pending' | 'in_progress' | 'completed';
+    status: 'pending' | 'completed';
     createdAt: string;
     updatedAt: string;
     parentId?: string;

package/dist/mcp/todo.js

@@ -190,35 +190,30 @@ Complete TODO list with all task IDs, content, status, and hierarchy.`,
             },
             {
                 name: 'todo-update',
-                description: `Update TODO status - USE SPARINGLY, focus on actual work instead.
+                description: `Update TODO status or content - USE ONLY WHEN COMPLETING TASKS.
 
-## CORE PRINCIPLE - WORK FIRST, UPDATES SECOND:
-Prioritize COMPLETING TASKS over updating TODO status. Update TODO only at natural breakpoints, not constantly. It's better to finish 3 tasks and update once than to update TODO 10 times while making slow progress.
+## CORE PRINCIPLE - WORK FIRST, UPDATES LAST:
+Focus on COMPLETING TASKS, not updating status. Only update TODO when a task is 100% finished and verified.
 
-## WHEN TO UPDATE (Sparingly):
-1. **Starting a major task**: Mark "in_progress" when beginning significant work (not for every micro-step)
-2. **Completing a major task**: Mark "completed" ONLY when task is 100% done and verified
-3. **Natural breakpoints**: When you finish a logical chunk of work
+## SIMPLIFIED STATUS MODEL:
+- **pending**: Task not yet completed (default)
+- **completed**: Task is 100% finished and verified
 
-## WHEN NOT TO UPDATE:
-- ❌ Every few minutes during work (you're wasting time on bookkeeping)
-- ❌ Multiple updates for sub-steps of one task (just finish the task first)
-- ❌ Immediately after starting (start working first, update later if it's a long task)
-- ❌ Before verifying the work is actually complete
-
-## SIMPLE RULES:
-- Keep MAXIMUM one task as "in_progress" (don't over-track)
-- Mark "completed" only when 100% done (no partial credit)
-- If you're spending more time updating TODO than working, you're doing it wrong
+## WHEN TO UPDATE:
+✅ **Mark "completed"** ONLY when:
+  - Task is 100% finished (no partial work)
+  - Tests/builds passed (if applicable)
+  - No errors or blockers
+  - You've actually verified it works
 
-## HONEST COMPLETION CRITERIA:
-Only mark complete if:
-- Task is 100% finished (no partial work)
-- Tests/builds passed (if applicable)
-- 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
 
-If blocked, keep as "in_progress" and report the blocker (don't create elaborate sub-TODO structures).`,
+## BEST PRACTICE:
+Complete 3-5 tasks, then batch update them all to "completed" at once. This is more efficient than constant status updates.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -228,8 +223,8 @@ If blocked, keep as "in_progress" and report the blocker (don't create elaborate
                         },
                         status: {
                             type: 'string',
-                            enum: ['pending', 'in_progress', 'completed'],
-                            description: 'New status - follow strict rules: "in_progress" when starting, "completed" when 100% done and verified, "pending" if not started',
+                            enum: ['pending', 'completed'],
+                            description: 'New status - "pending" (not done) or "completed" (100% finished and verified)',
                         },
                         content: {
                             type: 'string',

package/dist/ui/components/ChatInput.d.ts

@@ -22,5 +22,5 @@ type Props = {
     };
     snapshotFileCount?: Map<number, number>;
 };
-export default function ChatInput({ onSubmit, onCommand, placeholder, disabled, chatHistory, onHistorySelect, yoloMode, contextUsage, snapshotFileCount }: Props): React.JSX.Element;
+export default function ChatInput({ onSubmit, onCommand, placeholder, disabled, chatHistory, onHistorySelect, yoloMode, contextUsage, snapshotFileCount, }: Props): React.JSX.Element;
 export {};