vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/analysis/boundary-detector.js

@@ -7,24 +7,16 @@
 
 const fs = require('fs');
 const path = require('path');
+const BoundaryScanner = require('./boundary-scanner');
+const { 
+  BOUNDARY_TYPES,
+  groupBoundariesByType,
+  findBoundaryRelationships,
+  generateBoundaryRecommendations
+} = require('./boundary-utils');
 
 /**
- * Boundary types
- */
-const BOUNDARY_TYPES = {
-  FUNCTION: 'function',
-  CLASS: 'class',
-  MODULE: 'module',
-  BLOCK: 'block',
-  IMPORT: 'import',
-  EXPORT: 'export',
-  COMMENT: 'comment',
-  UTILITY: 'utility',
-  CONSTANT: 'constant'
-};
-
-/**
- * Boundary detection result class
+ * Boundary Detection Result class
  */
 class BoundaryDetectionResult {
   constructor(filePath) {
@@ -49,664 +41,269 @@ class BoundaryDetectionResult {
     this.metadata.byType[boundary.type]++;
   }
 
-  getBoundariesByType(type) {
-    return this.boundaries.filter(b => b.type === type);
-  }
-
-  getLargestBoundaries(count = 5) {
-    return this.boundaries
-      .sort((a, b) => b.lineCount - a.lineCount)
-      .slice(0, count);
-  }
-
-  getRefactoringCandidates() {
-    return this.boundaries.filter(b => 
-      b.lineCount > 50 && // Reasonable size
-      (b.type === BOUNDARY_TYPES.FUNCTION || b.type === BOUNDARY_TYPES.CLASS)
-    );
-  }
-}
-
-/**
- * Boundary class
- */
-class Boundary {
-  constructor(type, startLine, endLine, name = '') {
-    this.type = type;
-    this.startLine = startLine;
-    this.endLine = endLine;
-    this.name = name;
-    this.lineCount = endLine - startLine + 1;
-    this.complexity = 0;
-    this.dependencies = [];
-    this.exports = [];
-    this.comments = [];
-    this.metadata = {};
-  }
-
-  addDependency(dependency) {
-    this.dependencies.push(dependency);
-  }
-
-  addExport(exportName) {
-    this.exports.push(exportName);
-  }
-
-  addComment(comment) {
-    this.comments.push(comment);
-  }
-
-  setComplexity(complexity) {
-    this.complexity = complexity;
-  }
-
-  canExtract() {
-    // Basic criteria for extraction
-    return this.lineCount >= 10 && 
-           this.name !== '' && 
-           (this.type === BOUNDARY_TYPES.FUNCTION || this.type === BOUNDARY_TYPES.CLASS);
+  getSummary() {
+    return {
+      filePath: this.filePath,
+      totalBoundaries: this.metadata.totalBoundaries,
+      byType: this.metadata.byType,
+      averageSize: this.boundaries.length > 0 ? 
+        this.boundaries.reduce((sum, b) => sum + b.size, 0) / this.boundaries.length : 0,
+      complexity: this.metadata.complexity,
+      cohesion: this.metadata.cohesion,
+      coupling: this.metadata.coupling
+    };
   }
 }
 
 /**
- * Logical boundary detector class
+ * Boundary Detector class
  */
 class BoundaryDetector {
   constructor(options = {}) {
     this.options = {
-      minFunctionSize: 5,
-      minClassSize: 10,
-      detectComments: true,
-      detectUtilities: true,
+      includeComments: options.includeComments !== false,
+      includeImports: options.includeImports !== false,
+      includeExports: options.includeExports !== false,
+      minBoundarySize: options.minBoundarySize || 5,
+      analysisDepth: options.analysisDepth || 'standard',
       ...options
     };
+    
+    this.scanner = new BoundaryScanner(this.options);
   }
 
-  /**
-   * Detect boundaries in a file
-   */
   async detectBoundaries(filePath) {
-    const result = new BoundaryDetectionResult(filePath);
-    
     try {
-      const content = fs.readFileSync(filePath, 'utf8');
-      const lines = content.split('\n');
+      const content = await fs.promises.readFile(filePath, 'utf8');
+      const scanResult = this.scanner.scanFile(content, filePath);
       
-      // Detect based on file type
-      const ext = path.extname(filePath).toLowerCase();
+      const result = new BoundaryDetectionResult(filePath);
       
-      if (['.js', '.jsx', '.ts', '.tsx'].includes(ext)) {
-        await this.detectJavaScriptBoundaries(content, lines, result);
-      } else if (ext === '.md') {
-        await this.detectMarkdownBoundaries(content, lines, result);
-      } else {
-        await this.detectTextBoundaries(content, lines, result);
-      }
-
-      // Analyze overall structure
-      this.analyzeStructure(result);
-      
-    } catch (error) {
-      console.error(`Error detecting boundaries in ${filePath}: ${error.message}`);
-    }
-
-    return result;
-  }
-
-  /**
-   * Detect boundaries in JavaScript/TypeScript files
-   */
-  async detectJavaScriptBoundaries(content, lines, result) {
-    // Detect imports
-    this.detectImports(lines, result);
-    
-    // Detect exports
-    this.detectExports(lines, result);
-    
-    // Detect functions
-    this.detectFunctions(lines, result);
-    
-    // Detect classes
-    this.detectClasses(lines, result);
-    
-    // Detect utility sections
-    if (this.options.detectUtilities) {
-      this.detectUtilities(lines, result);
-    }
-    
-    // Detect comment blocks
-    if (this.options.detectComments) {
-      this.detectCommentBlocks(lines, result);
-    }
-  }
-
-  /**
-   * Detect import statements
-   */
-  detectImports(lines, result) {
-    let currentImport = null;
-    
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-      
-      if (line.startsWith('import ')) {
-        if (currentImport) {
-          // Close previous import
-          currentImport.endLine = i - 1;
-          currentImport.lineCount = currentImport.endLine - currentImport.startLine + 1;
-          result.addBoundary(currentImport);
-        }
-        
-        // Start new import
-        const match = line.match(/import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/);
-        currentImport = new Boundary(
-          BOUNDARY_TYPES.IMPORT,
-          i,
-          i,
-          match ? match[1] : 'import'
-        );
-      } else if (currentImport && (line.startsWith('from ') || line.endsWith(';'))) {
-        // End of import statement
-        currentImport.endLine = i;
-        currentImport.lineCount = currentImport.endLine - currentImport.startLine + 1;
-        result.addBoundary(currentImport);
-        currentImport = null;
-      }
-    }
-    
-    // Handle unclosed import
-    if (currentImport) {
-      currentImport.endLine = lines.length - 1;
-      currentImport.lineCount = currentImport.endLine - currentImport.startLine + 1;
-      result.addBoundary(currentImport);
-    }
-  }
-
-  /**
-   * Detect export statements
-   */
-  detectExports(lines, result) {
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-      
-      if (line.startsWith('export ')) {
-        const match = line.match(/export\s+(?:default\s+)?(?:function|class|const|let|var)\s+(\w+)/);
-        const name = match ? match[1] : 'export';
-        
-        const boundary = new Boundary(
-          BOUNDARY_TYPES.EXPORT,
-          i,
-          i,
-          name
-        );
-        
+      scanResult.boundaries.forEach(boundary => {
         result.addBoundary(boundary);
-      }
-    }
-  }
-
-  /**
-   * Detect function boundaries
-   */
-  detectFunctions(lines, result) {
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
+      });
       
-      // Function declarations
-      const funcMatch = line.match(/^(?:async\s+)?function\s+(\w+)/);
-      if (funcMatch) {
-        const boundary = this.findFunctionBoundary(lines, i, funcMatch[1], 'declaration');
-        if (boundary) result.addBoundary(boundary);
-        continue;
-      }
+      const relationships = findBoundaryRelationships(result.boundaries);
       
-      // Function expressions
-      const exprMatch = line.match(/^(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?function/);
-      if (exprMatch) {
-        const boundary = this.findFunctionBoundary(lines, i, exprMatch[1], 'expression');
-        if (boundary) result.addBoundary(boundary);
-        continue;
-      }
+      result.metadata.complexity = this.calculateOverallComplexity(result.boundaries);
+      result.metadata.cohesion = this.calculateOverallCohesion(result.boundaries);
+      result.metadata.coupling = this.calculateOverallCoupling(result.boundaries, relationships);
       
-      // Arrow functions
-      const arrowMatch = line.match(/^(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
-      if (arrowMatch) {
-        const boundary = this.findArrowFunctionBoundary(lines, i, arrowMatch[1]);
-        if (boundary) result.addBoundary(boundary);
-        continue;
-      }
+      result.metadata.scanMetadata = scanResult.metadata;
+      result.metadata.relationships = relationships;
       
-      // Method definitions in classes
-      const methodMatch = line.match(/^(\w+)\s*\(/);
-      if (methodMatch && this.isInClass(lines, i)) {
-        const boundary = this.findMethodBoundary(lines, i, methodMatch[1]);
-        if (boundary) result.addBoundary(boundary);
-      }
+      return result;
+
+    } catch (error) {
+      const result = new BoundaryDetectionResult(filePath);
+      result.metadata.error = error.message;
+      return result;
     }
   }
 
-  /**
-   * Find function boundary
-   */
-  findFunctionBoundary(lines, startLine, name, type) {
-    let braceCount = 0;
-    let foundBrace = false;
+  async detectBoundariesInFiles(filePaths) {
+    const results = [];
     
-    for (let i = startLine; i < lines.length; i++) {
-      const line = lines[i];
-      
-      for (let j = 0; j < line.length; j++) {
-        if (line[j] === '{') {
-          braceCount++;
-          foundBrace = true;
-        } else if (line[j] === '}') {
-          braceCount--;
-          if (foundBrace && braceCount === 0) {
-            const boundary = new Boundary(
-              BOUNDARY_TYPES.FUNCTION,
-              startLine,
-              i,
-              name
-            );
-            boundary.metadata.type = type;
-            return boundary;
-          }
-        }
-      }
+    for (const filePath of filePaths) {
+      const result = await this.detectBoundaries(filePath);
+      results.push(result);
     }
     
-    return null;
+    return results;
   }
 
-  /**
-   * Find arrow function boundary
-   */
-  findArrowFunctionBoundary(lines, startLine, name) {
-    let braceCount = 0;
-    let foundBrace = false;
-    let foundArrow = false;
-    
-    for (let i = startLine; i < lines.length; i++) {
-      const line = lines[i];
-      
-      if (line.includes('=>')) {
-        foundArrow = true;
-      }
-      
-      for (let j = 0; j < line.length; j++) {
-        if (line[j] === '{') {
-          braceCount++;
-          foundBrace = true;
-        } else if (line[j] === '}') {
-          braceCount--;
-          if (foundBrace && foundArrow && braceCount === 0) {
-            const boundary = new Boundary(
-              BOUNDARY_TYPES.FUNCTION,
-              startLine,
-              i,
-              name
-            );
-            boundary.metadata.type = 'arrow';
-            return boundary;
-          }
-        }
-      }
-    }
+  async detectBoundariesInDirectory(dirPath, options = {}) {
+    const scanOptions = {
+      recursive: options.recursive !== false,
+      extensions: options.extensions || ['.js', '.ts', '.jsx', '.tsx'],
+      exclude: options.exclude || ['node_modules', '.git', 'dist'],
+      ...options
+    };
     
-    return null;
+    const filePaths = await this.getFilePaths(dirPath, scanOptions);
+    return this.detectBoundariesInFiles(filePaths);
   }
 
-  /**
-   * Find method boundary
-   */
-  findMethodBoundary(lines, startLine, name) {
-    let braceCount = 0;
-    let foundBrace = false;
+  async getFilePaths(dirPath, options) {
+    const filePaths = [];
     
-    for (let i = startLine; i < lines.length; i++) {
-      const line = lines[i];
-      
-      for (let j = 0; j < line.length; j++) {
-        if (line[j] === '{') {
-          braceCount++;
-          foundBrace = true;
-        } else if (line[j] === '}') {
-          braceCount--;
-          if (foundBrace && braceCount === 0) {
-            const boundary = new Boundary(
-              BOUNDARY_TYPES.FUNCTION,
-              startLine,
-              i,
-              name
-            );
-            boundary.metadata.type = 'method';
-            return boundary;
-          }
-        }
+    const scanDirectory = async (currentPath, depth = 0) => {
+      if (depth > (options.maxDepth || 10)) {
+        return;
       }
-    }
-    
-    return null;
-  }
-
-  /**
-   * Detect class boundaries
-   */
-  detectClasses(lines, result) {
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
       
-      const classMatch = line.match(/^class\s+(\w+)/);
-      if (classMatch) {
-        const boundary = this.findClassBoundary(lines, i, classMatch[1]);
-        if (boundary) result.addBoundary(boundary);
-      }
-    }
-  }
-
-  /**
-   * Find class boundary
-   */
-  findClassBoundary(lines, startLine, name) {
-    let braceCount = 0;
-    let foundBrace = false;
-    
-    for (let i = startLine; i < lines.length; i++) {
-      const line = lines[i];
+      const entries = await fs.promises.readdir(currentPath, { withFileTypes: true });
       
-      for (let j = 0; j < line.length; j++) {
-        if (line[j] === '{') {
-          braceCount++;
-          foundBrace = true;
-        } else if (line[j] === '}') {
-          braceCount--;
-          if (foundBrace && braceCount === 0) {
-            return new Boundary(
-              BOUNDARY_TYPES.CLASS,
-              startLine,
-              i,
-              name
-            );
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        
+        if (entry.isDirectory()) {
+          if (options.exclude && !options.exclude.some(exclude => entry.name.includes(exclude))) {
+            if (options.recursive) {
+              await scanDirectory(fullPath, depth + 1);
+            }
+          }
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          if (options.extensions.includes(ext)) {
+            filePaths.push(fullPath);
           }
         }
       }
-    }
-    
-    return null;
-  }
-
-  /**
-   * Detect utility sections
-   */
-  detectUtilities(lines, result) {
-    // Look for sections with utility functions
-    let utilityStart = null;
-    let utilityName = null;
-    
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-      
-      // Detect utility section comments
-      if (line.startsWith('//') && (line.includes('utility') || line.includes('helper'))) {
-        if (utilityStart) {
-          // Close previous utility section
-          const boundary = new Boundary(
-            BOUNDARY_TYPES.UTILITY,
-            utilityStart,
-            i - 1,
-            utilityName || 'utilities'
-          );
-          result.addBoundary(boundary);
-        }
-        
-        utilityStart = i;
-        utilityName = line.replace('//', '').trim();
-      }
-    }
-    
-    // Close final utility section
-    if (utilityStart) {
-      const boundary = new Boundary(
-        BOUNDARY_TYPES.UTILITY,
-        utilityStart,
-        lines.length - 1,
-        utilityName || 'utilities'
-      );
-      result.addBoundary(boundary);
-    }
-  }
-
-  /**
-   * Detect comment blocks
-   */
-  detectCommentBlocks(lines, result) {
-    let commentStart = null;
-    let commentType = null;
+    };
     
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-      
-      if (line.startsWith('/*')) {
-        commentStart = i;
-        commentType = 'block';
-      } else if (line.startsWith('//')) {
-        // Single line comment
-        const boundary = new Boundary(
-          BOUNDARY_TYPES.COMMENT,
-          i,
-          i,
-          'single-line-comment'
-        );
-        result.addBoundary(boundary);
-      } else if (commentStart && line.endsWith('*/')) {
-        // End of block comment
-        const boundary = new Boundary(
-          BOUNDARY_TYPES.COMMENT,
-          commentStart,
-          i,
-          'block-comment'
-        );
-        result.addBoundary(boundary);
-        commentStart = null;
-        commentType = null;
-      }
-    }
-  }
-
-  /**
-   * Detect boundaries in Markdown files
-   */
-  async detectMarkdownBoundaries(content, lines, result) {
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      
-      // Headers
-      const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
-      if (headerMatch) {
-        const level = headerMatch[1].length;
-        const title = headerMatch[2];
-        
-        const boundary = new Boundary(
-          BOUNDARY_TYPES.MODULE,
-          i,
-          i,
-          title
-        );
-        boundary.metadata.level = level;
-        result.addBoundary(boundary);
-      }
-      
-      // Code blocks
-      if (line.startsWith('```')) {
-        const boundary = new Boundary(
-          BOUNDARY_TYPES.BLOCK,
-          i,
-          i,
-          'code-block'
-        );
-        result.addBoundary(boundary);
-      }
-    }
+    await scanDirectory(dirPath);
+    return filePaths;
   }
 
-  /**
-   * Detect boundaries in text files
-   */
-  async detectTextBoundaries(content, lines, result) {
-    // Simple paragraph detection
-    let paragraphStart = null;
+  calculateOverallComplexity(boundaries) {
+    if (boundaries.length === 0) return 'unknown';
     
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-      
-      if (line !== '') {
-        if (paragraphStart === null) {
-          paragraphStart = i;
-        }
-      } else {
-        if (paragraphStart !== null) {
-          const boundary = new Boundary(
-            BOUNDARY_TYPES.BLOCK,
-            paragraphStart,
-            i - 1,
-            'paragraph'
-          );
-          result.addBoundary(boundary);
-          paragraphStart = null;
-        }
-      }
-    }
+    const complexities = boundaries.map(b => b.complexity || 1);
+    const avgComplexity = complexities.reduce((sum, c) => sum + c, 0) / complexities.length;
     
-    // Handle final paragraph
-    if (paragraphStart !== null) {
-      const boundary = new Boundary(
-        BOUNDARY_TYPES.BLOCK,
-        paragraphStart,
-        lines.length - 1,
-        'paragraph'
-      );
-      result.addBoundary(boundary);
-    }
+    if (avgComplexity > 7) return 'very_high';
+    if (avgComplexity > 5) return 'high';
+    if (avgComplexity > 3) return 'medium';
+    if (avgComplexity > 2) return 'low';
+    return 'very_low';
   }
 
-  /**
-   * Check if line is inside a class
-   */
-  isInClass(lines, lineIndex) {
-    // Simple check - look backwards for class declaration
-    for (let i = lineIndex - 1; i >= 0; i--) {
-      const line = lines[i].trim();
-      if (line.startsWith('class ')) {
-        return true;
-      }
-      if (line.startsWith('function ') || line.startsWith('const ')) {
-        return false;
+  calculateOverallCohesion(boundaries) {
+    if (boundaries.length === 0) return 'unknown';
+    
+    const cohesions = boundaries.map(b => b.cohesion || 'medium');
+    const cohesionScores = cohesions.map(c => {
+      switch (c) {
+        case 'very_low': return 1;
+        case 'low': return 2;
+        case 'medium': return 3;
+        case 'high': return 4;
+        case 'very_high': return 5;
+        default: return 3;
       }
-    }
-    return false;
-  }
-
-  /**
-   * Analyze overall structure
-   */
-  analyzeStructure(result) {
-    // Calculate complexity metrics
-    const functions = result.getBoundariesByType(BOUNDARY_TYPES.FUNCTION);
-    const classes = result.getBoundariesByType(BOUNDARY_TYPES.CLASS);
-    
-    let totalComplexity = 0;
-    let totalSize = 0;
+    });
     
-    for (const boundary of [...functions, ...classes]) {
-      // Simple complexity estimation based on size
-      boundary.complexity = Math.min(10, Math.ceil(boundary.lineCount / 20));
-      totalComplexity += boundary.complexity;
-      totalSize += boundary.lineCount;
-    }
+    const avgCohesion = cohesionScores.reduce((sum, c) => sum + c, 0) / cohesionScores.length;
     
-    result.metadata.complexity = totalComplexity > 20 ? 'high' : 
-                               totalComplexity > 10 ? 'medium' : 'low';
-    
-    result.metadata.cohesion = this.assessCohesion(result);
-    result.metadata.coupling = this.assessCoupling(result);
+    if (avgCohesion > 4.5) return 'very_high';
+    if (avgCohesion > 3.5) return 'high';
+    if (avgCohesion > 2.5) return 'medium';
+    if (avgCohesion > 1.5) return 'low';
+    return 'very_low';
   }
 
-  /**
-   * Assess cohesion
-   */
-  assessCohesion(result) {
-    // Simple cohesion assessment based on boundary distribution
-    const functions = result.getBoundariesByType(BOUNDARY_TYPES.FUNCTION);
-    const avgFunctionSize = functions.length > 0 ? 
-      functions.reduce((sum, f) => sum + f.lineCount, 0) / functions.length : 0;
+  calculateOverallCoupling(boundaries, relationships) {
+    if (boundaries.length === 0) return 'unknown';
     
-    if (avgFunctionSize > 100) return 'low';
-    if (avgFunctionSize > 50) return 'medium';
-    return 'high';
-  }
-
-  /**
-   * Assess coupling
-   */
-  assessCoupling(result) {
-    // Simple coupling assessment based on imports
-    const imports = result.getBoundariesByType(BOUNDARY_TYPES.IMPORT);
-    
-    if (imports.length > 10) return 'high';
-    if (imports.length > 5) return 'medium';
-    return 'low';
+    const couplingScores = boundaries.map(b => {
+      const boundaryRelationships = relationships.filter(r => r.source === b.name);
+      if (boundaryRelationships.length === 0) return 5;
+      
+      const avgStrength = boundaryRelationships.reduce((sum, r) => sum + r.strength, 0) / boundaryRelationships.length;
+      
+      if (avgStrength > 4) return 1;
+      if (avgStrength > 3) return 2;
+      if (avgStrength > 2) return 3;
+      if (avgStrength > 1) return 4;
+      return 5;
+    });
+    
+    const avgCoupling = couplingScores.reduce((sum, c) => sum + c, 0) / couplingScores.length;
+    
+    if (avgCoupling > 4.5) return 'very_low';
+    if (avgCoupling > 3.5) return 'low';
+    if (avgCoupling > 2.5) return 'medium';
+    if (avgCoupling > 1.5) return 'high';
+    return 'very_high';
   }
 
-  /**
-   * Get refactoring recommendations
-   */
-  getRefactoringRecommendations(result) {
+  generateRefactoringRecommendations(result) {
     const recommendations = [];
     
-    // Large functions
-    const largeFunctions = result.getBoundariesByType(BOUNDARY_TYPES.FUNCTION)
-      .filter(f => f.lineCount > 50);
+    const boundaryRecommendations = generateBoundaryRecommendations(result.boundaries);
+    recommendations.push(...boundaryRecommendations);
     
-    if (largeFunctions.length > 0) {
+    if (result.metadata.totalBoundaries > 20) {
       recommendations.push({
-        type: 'extract_functions',
+        type: 'file_structure',
         priority: 'high',
-        description: `${largeFunctions.length} functions are too large and should be split`,
-        boundaries: largeFunctions.map(f => ({ name: f.name, lineCount: f.lineCount }))
+        message: 'File has too many boundaries (>20)',
+        action: 'split_into_modules'
       });
     }
     
-    // Large classes
-    const largeClasses = result.getBoundariesByType(BOUNDARY_TYPES.CLASS)
-      .filter(c => c.lineCount > 200);
-    
-    if (largeClasses.length > 0) {
+    if (result.metadata.complexity === 'very_high') {
       recommendations.push({
-        type: 'split_classes',
-        priority: 'medium',
-        description: `${largeClasses.length} classes are too large and should be split`,
-        boundaries: largeClasses.map(c => ({ name: c.name, lineCount: c.lineCount }))
+        type: 'complexity',
+        priority: 'high',
+        message: 'File has very high complexity',
+        action: 'reduce_complexity'
       });
     }
     
-    // Utility extraction
-    const utilities = result.getBoundariesByType(BOUNDARY_TYPES.UTILITY);
-    if (utilities.length === 0 && result.metadata.totalBoundaries > 5) {
+    if (result.metadata.cohesion === 'very_low') {
       recommendations.push({
-        type: 'extract_utilities',
-        priority: 'low',
-        description: 'Consider extracting utility functions to separate modules',
-        boundaries: []
+        type: 'cohesion',
+        priority: 'medium',
+        message: 'File has very low cohesion',
+        action: 'improve_cohesion'
       });
     }
     
     return recommendations;
   }
+
+  async exportResults(result, outputPath) {
+    const exportData = {
+      filePath: result.filePath,
+      timestamp: new Date().toISOString(),
+      summary: result.getSummary(),
+      boundaries: result.boundaries,
+      metadata: result.metadata,
+      recommendations: this.generateRefactoringRecommendations(result)
+    };
+    
+    await fs.promises.writeFile(outputPath, JSON.stringify(exportData, null, 2), 'utf8');
+  }
+
+  getDetectorInfo() {
+    return {
+      supportedTypes: Object.values(BOUNDARY_TYPES),
+      defaultOptions: this.options,
+      features: [
+        'boundary detection',
+        'complexity analysis',
+        'cohesion calculation',
+        'coupling analysis',
+        'refactoring recommendations',
+        'batch processing'
+      ],
+      version: '1.0.0'
+    };
+  }
+
+  static createDefault(config = {}) {
+    return new BoundaryDetector({
+      includeComments: true,
+      includeImports: true,
+      includeExports: true,
+      minBoundarySize: 5,
+      analysisDepth: 'standard',
+      ...config
+    });
+  }
+
+  static createForRefactoring(config = {}) {
+    return new BoundaryDetector({
+      includeComments: false,
+      includeImports: true,
+      includeExports: true,
+      minBoundarySize: 10,
+      analysisDepth: 'deep',
+      ...config
+    });
+  }
 }
 
-module.exports = {
-  BoundaryDetector,
-  BoundaryDetectionResult,
-  Boundary,
-  BOUNDARY_TYPES
-};
+module.exports = BoundaryDetector;