cntx-ui 2.0.15 → 3.0.1

package/lib/semantic-splitter.js

@@ -1,588 +1,329 @@
 /**
- * True Semantic Splitting - Function-level code chunks with context
- * Creates surgical, self-contained chunks for AI consumption
- * Operates parallel to file-level bundle system
+ * Semantic Splitter - High-Performance AST-based Chunker
+ * Uses tree-sitter for surgical, function-level code extraction
+ * Integrated with HeuristicsManager for intelligent categorization
  */
 
 import { readFileSync, existsSync } from 'fs'
-import { extname, basename, dirname, join } from 'path'
+import { join, extname } from 'path'
 import glob from 'glob'
+import Parser from 'tree-sitter'
+import JavaScript from 'tree-sitter-javascript'
+import TypeScript from 'tree-sitter-typescript'
 import HeuristicsManager from './heuristics-manager.js'
 
 export default class SemanticSplitter {
   constructor(options = {}) {
     this.options = {
-      maxChunkSize: 2000,       // Max chars per chunk
+      maxChunkSize: 3000,       // Max chars per chunk
       includeContext: true,     // Include imports/types needed
-      groupRelated: true,       // Group related functions
-      minFunctionSize: 50,      // Skip tiny functions
+      minFunctionSize: 40,      // Skip tiny functions
       ...options
     }
     
-    // Initialize heuristics manager
+    // Initialize tree-sitter parsers
+    this.parsers = {
+      javascript: new Parser(),
+      typescript: new Parser(),
+      tsx: new Parser()
+    }
+    this.parsers.javascript.setLanguage(JavaScript)
+    this.parsers.typescript.setLanguage(TypeScript.typescript)
+    this.parsers.tsx.setLanguage(TypeScript.tsx)
+
     this.heuristicsManager = new HeuristicsManager()
   }
 
+  getParser(filePath) {
+    const ext = extname(filePath)
+    switch (ext) {
+      case '.ts': return this.parsers.typescript
+      case '.tsx': return this.parsers.tsx
+      default: return this.parsers.javascript
+    }
+  }
+
   /**
-   * Extract semantic chunks from project
+   * Main entry point - extract semantic chunks from project
    */
   async extractSemanticChunks(projectPath, patterns = ['**/*.{js,jsx,ts,tsx,mjs}'], bundleConfig = null) {
-    console.log('🔪 Starting semantic splitting...')
-    
-    const files = this.findFiles(projectPath, patterns)
-    console.log(`📁 Found ${files.length} files to split`)
-    
-    // Load bundle configuration if provided
-    this.bundleConfig = bundleConfig
+    console.log('🔪 Starting surgical semantic splitting via tree-sitter...');
+    console.log(`📂 Project path: ${projectPath}`);
+    console.log(`📋 Patterns: ${patterns}`);
+    
+    this.bundleConfig = bundleConfig;
+    const files = this.findFiles(projectPath, patterns);
+    console.log(`📁 Found ${files.length} files to split`);
+    if (files.length > 0) {
+      console.log('📄 Sample files:', files.slice(0, 5));
+    }
     
-    const allFunctions = []
-    const allTypes = []
-    const allImports = []
+    const allChunks = []
     
-    // Extract all code elements
     for (const filePath of files) {
       try {
-        const elements = this.extractCodeElements(filePath, projectPath)
-        allFunctions.push(...elements.functions)
-        allTypes.push(...elements.types)
-        allImports.push(...elements.imports)
+        const fileChunks = this.processFile(filePath, projectPath)
+        allChunks.push(...fileChunks)
       } catch (error) {
-        console.warn(`Failed to extract from ${filePath}: ${error.message}`)
+        console.warn(`Failed to process ${filePath}: ${error.message}`)
       }
     }
     
-    console.log(`⚡ Extracted ${allFunctions.length} functions, ${allTypes.length} types`)
-    
-    // Create semantic chunks
-    const chunks = this.createSemanticChunks(allFunctions, allTypes, allImports)
-    console.log(`🧩 Created ${chunks.length} semantic chunks`)
-    
+    console.log(`🧩 Created ${allChunks.length} semantic chunks across project`)
     return {
       summary: {
         totalFiles: files.length,
-        totalFunctions: allFunctions.length,
-        totalChunks: chunks.length,
-        averageChunkSize: chunks.reduce((sum, c) => sum + c.code.length, 0) / chunks.length
+        totalChunks: allChunks.length,
+        averageSize: allChunks.reduce((sum, c) => sum + c.code.length, 0) / allChunks.length
       },
-      chunks: chunks
+      chunks: allChunks
     }
   }
 
-  /**
-   * Find files to analyze (same logic as bundles)
-   */
   findFiles(projectPath, patterns) {
     const files = []
-    
     for (const pattern of patterns) {
       const matches = glob.sync(pattern, {
         cwd: projectPath,
-        ignore: [
-          'node_modules/**', 'dist/**', 'build/**', '.git/**',
-          '*.test.*', '*.spec.*', '**/test/**', '**/tests/**',
-          '**/*.min.js', '**/*.bundle.js'
-        ]
+        ignore: ['node_modules/**', 'dist/**', '.git/**', '*.test.*', '*.spec.*']
       })
-      
-      files.push(...matches.filter(file => 
-        !file.includes('node_modules') && 
-        !file.includes('dist/') &&
-        !file.includes('.min.')
-      ))
+      files.push(...matches)
     }
-    
     return [...new Set(files)]
   }
 
-  /**
-   * Extract functions, types, and imports from a file
-   */
-  extractCodeElements(relativePath, projectPath) {
-    const fullPath = join(projectPath, relativePath)
-    if (!existsSync(fullPath)) return { functions: [], types: [], imports: [] }
-    
-    const content = readFileSync(fullPath, 'utf8')
-    const lines = content.split('\n')
-    
-    return {
-      functions: this.extractFunctions(content, lines, relativePath),
-      types: this.extractTypes(content, lines, relativePath),
-      imports: this.extractImports(content, relativePath)
-    }
-  }
+  processFile(relativePath, projectPath) {
+    const fullPath = join(projectPath, relativePath);
+    if (!existsSync(fullPath)) return [];
+    
+    // console.log(`  📄 Processing: ${relativePath}`);
+    const content = readFileSync(fullPath, 'utf8');
+    const parser = this.getParser(relativePath);
+    const tree = parser.parse(content);
+    const root = tree.rootNode;
+    
+    const elements = {
+      functions: [],
+      types: [],
+      imports: this.extractImports(root, content, relativePath)
+    };
 
-  /**
-   * Extract functions with robust regex patterns
-   */
-  extractFunctions(content, lines, filePath) {
-    const functions = []
-    
-    // Pattern 1: Regular function declarations
-    const functionRegex = /^(\s*)(?:export\s+)?(?:async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*\{/gm
-    
-    // Pattern 2: Arrow functions assigned to const/let
-    const arrowRegex = /^(\s*)(?:export\s+)?const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>\s*[\{]/gm
-    
-    // Pattern 3: Class methods
-    const methodRegex = /^(\s+)(?:async\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*\{/gm
-    
-    // Pattern 4: React components (function components)
-    const componentRegex = /^(\s*)(?:export\s+(?:default\s+)?)?function\s+([A-Z][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*\{/gm
-    
-    const patterns = [
-      { regex: functionRegex, type: 'function' },
-      { regex: arrowRegex, type: 'arrow_function' },
-      { regex: methodRegex, type: 'method' },
-      { regex: componentRegex, type: 'react_component' }
-    ]
-    
-    for (const { regex, type } of patterns) {
-      let match
-      while ((match = regex.exec(content)) !== null) {
-        const functionName = match[2]
-        const indentation = match[1]
-        const startIndex = match.index
-        
-        // Skip if it's a keyword or common false positive
-        if (['if', 'for', 'while', 'switch', 'catch'].includes(functionName)) {
-          continue
-        }
-        
-        const startLine = content.substring(0, startIndex).split('\n').length
-        const functionBody = this.extractFunctionBody(content, startIndex)
-        
-        if (functionBody && functionBody.length > this.options.minFunctionSize) {
-          functions.push({
-            name: functionName,
-            type: type,
-            filePath: filePath,
-            startLine: startLine,
-            code: functionBody,
-            indentation: indentation.length,
-            isExported: match[0].includes('export'),
-            isAsync: match[0].includes('async'),
-            size: functionBody.length
-          })
-        }
-      }
-    }
-    
-    return functions
-  }
+    // Traverse AST for functions and types
+    this.traverse(root, content, relativePath, elements);
 
-  /**
-   * Extract function body using brace matching
-   */
-  extractFunctionBody(content, startIndex) {
-    const openBraceIndex = content.indexOf('{', startIndex)
-    if (openBraceIndex === -1) return null
-    
-    let braceCount = 0
-    let currentIndex = openBraceIndex
-    let inString = false
-    let stringChar = null
-    
-    while (currentIndex < content.length) {
-      const char = content[currentIndex]
-      const prevChar = content[currentIndex - 1] || ''
-      
-      // Handle string literals
-      if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
-        if (!inString) {
-          inString = true
-          stringChar = char
-        } else if (char === stringChar) {
-          inString = false
-          stringChar = null
-        }
-      }
-      
-      // Count braces outside strings
-      if (!inString) {
-        if (char === '{') braceCount++
-        else if (char === '}') braceCount--
-        
-        if (braceCount === 0) {
-          // Found the closing brace
-          return content.substring(startIndex, currentIndex + 1).trim()
-        }
-      }
-      
-      currentIndex++
-    }
-    
-    return null // Unmatched braces
+    const chunks = this.createChunks(elements, content, relativePath);
+    // if (chunks.length > 0) {
+    //   console.log(`    ✅ Found ${chunks.length} chunks in ${relativePath}`);
+    // }
+    return chunks;
   }
 
-  /**
-   * Extract type definitions and interfaces
-   */
-  extractTypes(content, lines, filePath) {
-    const types = []
-    
-    // TypeScript interfaces
-    const interfaceRegex = /^(\s*)(?:export\s+)?interface\s+([A-Z][a-zA-Z0-9_$]*)\s*\{/gm
-    
-    // Type aliases
-    const typeRegex = /^(\s*)(?:export\s+)?type\s+([A-Z][a-zA-Z0-9_$]*)\s*=/gm
-    
-    const patterns = [
-      { regex: interfaceRegex, type: 'interface' },
-      { regex: typeRegex, type: 'type_alias' }
-    ]
-    
-    for (const { regex, type } of patterns) {
-      let match
-      while ((match = regex.exec(content)) !== null) {
-        const typeName = match[2]
-        const startIndex = match.index
-        const startLine = content.substring(0, startIndex).split('\n').length
-        
-        let typeBody
-        if (type === 'interface') {
-          typeBody = this.extractTypeBody(content, startIndex)
-        } else {
-          // For type aliases, extract until semicolon or newline
-          const endIndex = content.indexOf(';', startIndex)
-          typeBody = content.substring(startIndex, endIndex + 1).trim()
-        }
-        
-        if (typeBody) {
-          types.push({
-            name: typeName,
-            type: type,
-            filePath: filePath,
-            startLine: startLine,
-            code: typeBody,
-            isExported: match[0].includes('export')
-          })
-        }
+  traverse(node, content, filePath, elements) {
+    // Detect Function Declarations
+    if (node.type === 'function_declaration' || node.type === 'method_definition' || node.type === 'arrow_function') {
+      const func = this.mapFunctionNode(node, content, filePath)
+      if (func && func.code.length > this.options.minFunctionSize) {
+        elements.functions.push(func)
       }
     }
-    
-    return types
-  }
 
-  /**
-   * Extract type body (similar to function body)
-   */
-  extractTypeBody(content, startIndex) {
-    const openBraceIndex = content.indexOf('{', startIndex)
-    if (openBraceIndex === -1) return null
-    
-    let braceCount = 0
-    let currentIndex = openBraceIndex
-    
-    while (currentIndex < content.length) {
-      const char = content[currentIndex]
-      
-      if (char === '{') braceCount++
-      else if (char === '}') braceCount--
-      
-      if (braceCount === 0) {
-        return content.substring(startIndex, currentIndex + 1).trim()
-      }
-      
-      currentIndex++
+    // Detect Type Definitions (TS)
+    if (node.type === 'interface_declaration' || node.type === 'type_alias_declaration') {
+      const typeDef = this.mapTypeNode(node, content, filePath)
+      if (typeDef) elements.types.push(typeDef)
     }
-    
-    return null
-  }
 
-  /**
-   * Extract import statements
-   */
-  extractImports(content, filePath) {
-    const imports = []
-    const importRegex = /^(\s*)import\s+(.+?)\s+from\s+['"`]([^'"`]+)['"`]/gm
-    
-    let match
-    while ((match = importRegex.exec(content)) !== null) {
-      const importStatement = match[0].trim()
-      const importPath = match[3]
-      
-      imports.push({
-        statement: importStatement,
-        path: importPath,
-        filePath: filePath,
-        isRelative: importPath.startsWith('.'),
-        isExternal: !importPath.startsWith('.')
-      })
-    }
-    
-    return imports
-  }
-
-  /**
-   * Create semantic chunks from extracted elements
-   */
-  createSemanticChunks(functions, types, imports) {
-    const chunks = []
-    
-    // Create function-level chunks
-    for (const func of functions) {
-      const chunk = this.createFunctionChunk(func, types, imports)
-      if (chunk) {
-        chunks.push(chunk)
+    // Recurse unless we've already captured the block (like a function body)
+    if (node.type !== 'function_declaration' && node.type !== 'method_definition') {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        this.traverse(node.namedChild(i), content, filePath, elements)
       }
     }
-    
-    // Create type-only chunks for standalone types
-    for (const type of types) {
-      if (!this.isTypeUsedInFunctions(type, functions)) {
-        chunks.push(this.createTypeChunk(type, imports))
-      }
-    }
-    
-    return chunks
   }
 
-  /**
-   * Create a semantic chunk for a function with its context
-   */
-  createFunctionChunk(func, allTypes, allImports) {
-    let chunkCode = ''
-    const includedImports = new Set()
-    const includedTypes = new Set()
-    
-    // Find relevant imports for this function
-    const fileImports = allImports.filter(imp => imp.filePath === func.filePath)
-    
-    // Find types referenced in the function
-    const referencedTypes = this.findReferencedTypes(func.code, allTypes)
-    
-    // Add necessary imports
-    for (const imp of fileImports) {
-      if (this.isImportRelevant(imp, func.code)) {
-        chunkCode += imp.statement + '\n'
-        includedImports.add(imp.path)
+  mapFunctionNode(node, content, filePath) {
+    let name = 'anonymous';
+    
+    // Find name identifier based on node type
+    if (node.type === 'function_declaration' || node.type === 'method_definition') {
+      const nameNode = node.childForFieldName('name');
+      if (nameNode) name = content.slice(nameNode.startIndex, nameNode.endIndex);
+    } else if (node.type === 'arrow_function') {
+      // 1. Check if assigned to a variable: const foo = () => {}
+      const parent = node.parent;
+      if (parent && parent.type === 'variable_declarator') {
+        const nameNode = parent.childForFieldName('name');
+        if (nameNode) name = content.slice(nameNode.startIndex, nameNode.endIndex);
       }
-    }
-    
-    // Add referenced types
-    for (const type of referencedTypes) {
-      chunkCode += '\n' + type.code + '\n'
-      includedTypes.add(type.name)
-    }
-    
-    // Add the function itself
-    chunkCode += '\n' + func.code
-    
-    // Create chunk with adaptive sizing - never lose functions
-    let finalCode = chunkCode.trim()
-    let contextLevel = 'full'
-    
-    // If too large, try with reduced context
-    if (chunkCode.length > this.options.maxChunkSize) {
-      // Fallback 1: Function + essential imports only (no types)
-      finalCode = ''
-      for (const imp of fileImports.slice(0, 3)) { // Limit to 3 imports
-        if (this.isImportRelevant(imp, func.code)) {
-          finalCode += imp.statement + '\n'
-        }
+      // 2. Check if part of an object property: { foo: () => {} }
+      else if (parent && parent.type === 'pair') {
+        const keyNode = parent.childForFieldName('key');
+        if (keyNode) name = content.slice(keyNode.startIndex, keyNode.endIndex);
+      }
+      // 3. Check if part of an assignment: this.foo = () => {}
+      else if (parent && parent.type === 'assignment_expression') {
+        const leftNode = parent.childForFieldName('left');
+        if (leftNode) name = content.slice(leftNode.startIndex, leftNode.endIndex);
       }
-      finalCode += '\n' + func.code
-      contextLevel = 'reduced'
-    }
-    
-    // If still too large, function only
-    if (finalCode.length > this.options.maxChunkSize) {
-      finalCode = func.code
-      contextLevel = 'minimal'
     }
+
+    const code = content.slice(node.startIndex, node.endIndex)
     
-    // Always create a chunk - never lose functions
     return {
-      name: func.name,
-      type: 'function_chunk',
-      subtype: func.type,
-      code: finalCode,
-      size: finalCode.length,
-      filePath: func.filePath,
-      startLine: func.startLine,
-      isExported: func.isExported,
-      isAsync: func.isAsync,
-      complexity: this.calculateComplexity(func.code),
-      includes: {
-        imports: contextLevel === 'minimal' ? [] : Array.from(includedImports),
-        types: contextLevel === 'full' ? Array.from(includedTypes) : []
-      },
-      purpose: this.determinePurpose(func),
-      tags: [...this.generateTags(func), contextLevel === 'full' ? 'full-context' : contextLevel === 'reduced' ? 'reduced-context' : 'minimal-context'],
-      bundles: this.getFileBundles(func.filePath)
+      name,
+      type: node.type,
+      filePath,
+      startLine: node.startPosition.row + 1,
+      code,
+      isExported: this.isExported(node),
+      isAsync: code.includes('async')
     }
   }
 
-  /**
-   * Create a chunk for standalone types
-   */
-  createTypeChunk(type, allImports) {
-    let chunkCode = ''
-    const includedImports = new Set()
-    
-    // Add relevant imports if any
-    const fileImports = allImports.filter(imp => imp.filePath === type.filePath)
-    for (const imp of fileImports.slice(0, 3)) { // Limit imports
-      chunkCode += imp.statement + '\n'
-    }
-    
-    chunkCode += '\n' + type.code
+  mapTypeNode(node, content, filePath) {
+    const nameNode = node.childForFieldName('name')
+    if (!nameNode) return null
     
     return {
-      name: type.name,
-      type: 'type_chunk',
-      subtype: type.type,
-      code: chunkCode.trim(),
-      size: chunkCode.length,
-      filePath: type.filePath,
-      startLine: type.startLine,
-      isExported: type.isExported,
-      purpose: 'Type definition',
-      tags: ['type', type.type],
-      bundles: this.getFileBundles(type.filePath)
+      name: content.slice(nameNode.startIndex, nameNode.endIndex),
+      type: node.type,
+      filePath,
+      startLine: node.startPosition.row + 1,
+      code: content.slice(node.startIndex, node.endIndex),
+      isExported: this.isExported(node)
     }
   }
 
-  /**
-   * Find types referenced in function code
-   */
-  findReferencedTypes(functionCode, allTypes) {
-    const referenced = []
-    
-    for (const type of allTypes) {
-      // Check if type name appears in function code
-      const typeRegex = new RegExp(`\\b${type.name}\\b`, 'g')
-      if (typeRegex.test(functionCode)) {
-        referenced.push(type)
+  extractImports(root, content, filePath) {
+    const imports = []
+    // Simple traversal for import statements
+    for (let i = 0; i < root.namedChildCount; i++) {
+      const node = root.namedChild(i)
+      if (node.type === 'import_statement') {
+        imports.push({
+          statement: content.slice(node.startIndex, node.endIndex),
+          filePath
+        })
       }
     }
-    
-    return referenced
+    return imports
   }
 
-  /**
-   * Check if import is relevant to function
-   */
-  isImportRelevant(importStatement, functionCode) {
-    // Simple heuristic: check if any imported identifiers appear in function
-    const importMatch = importStatement.statement.match(/import\s+(.+?)\s+from/)
-    if (!importMatch) return false
-    
-    const imported = importMatch[1]
-    
-    // Handle different import styles
-    if (imported.includes('{')) {
-      // Named imports: import { foo, bar } from 'module'
-      const namedImports = imported.match(/\{([^}]+)\}/)?.[1]
-      if (namedImports) {
-        const names = namedImports.split(',').map(name => name.trim())
-        return names.some(name => functionCode.includes(name))
-      }
-    } else {
-      // Default import: import foo from 'module'
-      const defaultImport = imported.trim()
-      return functionCode.includes(defaultImport)
+  isExported(node) {
+    let current = node
+    while (current) {
+      if (current.type === 'export_statement') return true
+      current = current.parent
     }
-    
     return false
   }
 
-  /**
-   * Check if type is used in any function
-   */
-  isTypeUsedInFunctions(type, functions) {
-    const typeRegex = new RegExp(`\\b${type.name}\\b`, 'g')
-    return functions.some(func => typeRegex.test(func.code))
-  }
+  createChunks(elements, content, filePath) {
+    const chunks = [];
+    const pathParts = filePath.toLowerCase().split(/[\\\/]/);
+    
+    for (const func of elements.functions) {
+      // Pass full context to heuristics
+      const heuristicContext = {
+        ...func,
+        includes: elements,
+        pathParts
+      };
+      
+      const purpose = this.heuristicsManager.determinePurpose(heuristicContext);
+      const businessDomain = this.heuristicsManager.inferBusinessDomains(heuristicContext);
+      const technicalPatterns = this.heuristicsManager.inferTechnicalPatterns(heuristicContext);
+      const tags = this.generateTags(func);
 
-  /**
-   * Calculate function complexity (cyclomatic complexity)
-   */
-  calculateComplexity(code) {
-    let complexity = 1 // Base complexity
-    
-    // Simple complexity indicators - just count control flow structures
-    const indicators = {
-      'if': (code.match(/\bif\s*\(/g) || []).length,
-      'else if': (code.match(/\belse\s+if\b/g) || []).length,
-      'for': (code.match(/\bfor\s*\(/g) || []).length,
-      'while': (code.match(/\bwhile\s*\(/g) || []).length,
-      'switch': (code.match(/\bswitch\s*\(/g) || []).length,
-      'case': (code.match(/\bcase\s+/g) || []).length,
-      'catch': (code.match(/\bcatch\s*\(/g) || []).length,
-      'ternary': (code.match(/\?\s*[^?\.\s]/g) || []).length,
-      'logical_and': (code.match(/&&\s*[^&=]/g) || []).length,
-      'logical_or': (code.match(/\|\|\s*[^|=]/g) || []).length
-    }
-    
-    // Sum all complexity indicators
-    for (const count of Object.values(indicators)) {
-      complexity += count
+      // if (businessDomain.length > 0) {
+      //   console.log(`  💎 ${func.name}: Domains: [${businessDomain}], Patterns: [${technicalPatterns}]`);
+      // }
+
+      let chunkCode = '';
+      if (this.options.includeContext) {
+        const relevantImports = elements.imports
+          .filter(imp => this.isImportRelevant(imp.statement, func.code))
+          .map(imp => imp.statement)
+          .join('\n');
+        
+        if (relevantImports) chunkCode += relevantImports + '\n\n';
+      }
+      chunkCode += func.code;
+
+      chunks.push({
+        id: `${filePath}:${func.name}:${func.startLine}`,
+        name: func.name,
+        filePath,
+        type: 'function',
+        subtype: func.type,
+        code: chunkCode,
+        startLine: func.startLine,
+        complexity: this.calculateComplexity(func.code),
+        purpose,
+        tags,
+        businessDomain,
+        technicalPatterns,
+        includes: {
+          imports: elements.imports.map(i => i.statement),
+          types: elements.types.map(t => t.name)
+        },
+        bundles: this.getFileBundles(filePath)
+      });
     }
     
-    // Return complexity with reasonable thresholds
-    return {
-      score: complexity,
-      level: complexity <= 3 ? 'low' : complexity <= 8 ? 'medium' : 'high'
-    }
+    return chunks;
   }
 
-  /**
-   * Determine function purpose using heuristics configuration
-   */
-  determinePurpose(func) {
-    return this.heuristicsManager.determinePurpose(func)
+  isImportRelevant(importStatement, functionCode) {
+    // Heuristic: does the function use any name from the import?
+    const match = importStatement.match(/import\s+(?:\{([^}]+)\}|(\w+))/i)
+    if (!match) return false
+    const importedNames = match[1] ? match[1].split(',').map(n => n.trim()) : [match[2]]
+    return importedNames.some(name => functionCode.includes(name))
+  }
+
+  calculateComplexity(code) {
+    const indicators = ['if', 'else', 'for', 'while', 'switch', 'case', 'catch', '?', '&&', '||'];
+    let score = 1;
+    indicators.forEach(ind => {
+      // Escape special regex characters
+      const escaped = ind.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      // Only use word boundaries for word-like indicators
+      const pattern = /^[a-zA-Z]+$/.test(ind) ? `\\b${escaped}\\b` : escaped;
+      const regex = new RegExp(pattern, 'g');
+      score += (code.match(regex) || []).length;
+    });
+    return {
+      score,
+      level: score < 5 ? 'low' : score < 15 ? 'medium' : 'high'
+    };
   }
 
-  /**
-   * Generate tags for function
-   */
   generateTags(func) {
     const tags = [func.type]
-    
     if (func.isExported) tags.push('exported')
     if (func.isAsync) tags.push('async')
-    if (func.size > 1000) tags.push('large')
-    if (func.code.includes('console.log')) tags.push('has-logging')
-    if (func.code.includes('throw')) tags.push('can-throw')
-    if (func.code.includes('return')) tags.push('returns-value')
-    
+    if (func.code.length > 2000) tags.push('large')
     return tags
   }
 
-  /**
-   * Determine which bundles a file belongs to
-   */
   getFileBundles(filePath) {
     if (!this.bundleConfig?.bundles) return []
-    
     const bundles = []
-    for (const [bundleName, patterns] of Object.entries(this.bundleConfig.bundles)) {
-      // Skip master bundle as requested
-      if (bundleName === 'master') continue
-      
-      // Check if file matches any pattern in this bundle
+    for (const [name, patterns] of Object.entries(this.bundleConfig.bundles)) {
+      if (name === 'master') continue
       for (const pattern of patterns) {
         if (this.matchesPattern(filePath, pattern)) {
-          bundles.push(bundleName)
-          break // Don't add the same bundle multiple times
+          bundles.push(name)
+          break
         }
       }
     }
-    
     return bundles
   }
 
-  /**
-   * Simple pattern matching (basic glob support)
-   */
   matchesPattern(filePath, pattern) {
-    // Convert glob pattern to regex
-    const regex = pattern
-      .replace(/\*\*/g, '.*')  // ** matches any directories
-      .replace(/\*/g, '[^/]*') // * matches any characters except /
-      .replace(/\./g, '\\.')   // Escape dots
-    
+    const regex = pattern.replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*').replace(/\./g, '\\.')
     return new RegExp(`^${regex}$`).test(filePath)
   }
-}
+}