vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/analysis/boundary-detector-refactored.js

@@ -0,0 +1,378 @@
+/**
+ * Logical Boundary Detector
+ * 
+ * Uses AST analysis to detect logical boundaries in files for refactoring.
+ * Identifies functions, classes, modules, and other logical segments.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const BoundaryScanner = require('./boundary-scanner');
+const { 
+  BOUNDARY_TYPES,
+  groupBoundariesByType,
+  findBoundaryRelationships,
+  generateBoundaryRecommendations
+} = require('./boundary-utils');
+
+/**
+ * Boundary Detection Result class
+ */
+class BoundaryDetectionResult {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.boundaries = [];
+    this.metadata = {
+      totalBoundaries: 0,
+      byType: {},
+      complexity: 'unknown',
+      cohesion: 'unknown',
+      coupling: 'unknown'
+    };
+  }
+
+  addBoundary(boundary) {
+    this.boundaries.push(boundary);
+    this.metadata.totalBoundaries++;
+    
+    if (!this.metadata.byType[boundary.type]) {
+      this.metadata.byType[boundary.type] = 0;
+    }
+    this.metadata.byType[boundary.type]++;
+  }
+
+  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
+    };
+  }
+}
+
+/**
+ * Boundary Detector class
+ */
+class BoundaryDetector {
+  constructor(options = {}) {
+    this.options = {
+      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 file
+   * @param {string} filePath - Path to file
+   * @returns {Promise<BoundaryDetectionResult>} - Detection result
+   */
+  async detectBoundaries(filePath) {
+    try {
+      const content = await fs.promises.readFile(filePath, 'utf8');
+      const scanResult = this.scanner.scanFile(content, filePath);
+      
+      const result = new BoundaryDetectionResult(filePath);
+      
+      // Add all detected boundaries
+      scanResult.boundaries.forEach(boundary => {
+        result.addBoundary(boundary);
+      });
+      
+      // Analyze relationships
+      const relationships = findBoundaryRelationships(result.boundaries);
+      
+      // Calculate overall metrics
+      result.metadata.complexity = this.calculateOverallComplexity(result.boundaries);
+      result.metadata.cohesion = this.calculateOverallCohesion(result.boundaries);
+      result.metadata.coupling = this.calculateOverallCoupling(result.boundaries, relationships);
+      
+      // Add scan metadata
+      result.metadata.scanMetadata = scanResult.metadata;
+      result.metadata.relationships = relationships;
+      
+      return result;
+
+    } catch (error) {
+      const result = new BoundaryDetectionResult(filePath);
+      result.metadata.error = error.message;
+      return result;
+    }
+  }
+
+  /**
+   * Detect boundaries in multiple files
+   * @param {Array} filePaths - Array of file paths
+   * @returns {Promise<Array>} - Array of detection results
+   */
+  async detectBoundariesInFiles(filePaths) {
+    const results = [];
+    
+    for (const filePath of filePaths) {
+      const result = await this.detectBoundaries(filePath);
+      results.push(result);
+    }
+    
+    return results;
+  }
+
+  /**
+   * Detect boundaries in directory
+   * @param {string} dirPath - Directory path
+   * @param {Object} options - Scan options
+   * @returns {Promise<Array>} - Array of detection results
+   */
+  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
+    };
+    
+    const filePaths = await this.getFilePaths(dirPath, scanOptions);
+    return this.detectBoundariesInFiles(filePaths);
+  }
+
+  /**
+   * Get file paths from directory
+   * @param {string} dirPath - Directory path
+   * @param {Object} options - Scan options
+   * @returns {Promise<Array>} - Array of file paths
+   */
+  async getFilePaths(dirPath, options) {
+    const filePaths = [];
+    
+    const scanDirectory = async (currentPath, depth = 0) => {
+      if (depth > (options.maxDepth || 10)) {
+        return;
+      }
+      
+      const entries = await fs.promises.readdir(currentPath, { withFileTypes: true });
+      
+      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);
+          }
+        }
+      }
+    };
+    
+    await scanDirectory(dirPath);
+    return filePaths;
+  }
+
+  /**
+   * Calculate overall complexity
+   * @param {Array} boundaries - Array of boundaries
+   * @returns {string} - Complexity level
+   */
+  calculateOverallComplexity(boundaries) {
+    if (boundaries.length === 0) return 'unknown';
+    
+    const complexities = boundaries.map(b => b.complexity || 1);
+    const avgComplexity = complexities.reduce((sum, c) => sum + c, 0) / complexities.length;
+    
+    if (avgComplexity > 7) return 'very_high';
+    if (avgComplexity > 5) return 'high';
+    if (avgComplexity > 3) return 'medium';
+    if (avgComplexity > 2) return 'low';
+    return 'very_low';
+  }
+
+  /**
+   * Calculate overall cohesion
+   * @param {Array} boundaries - Array of boundaries
+   * @returns {string} - Cohesion level
+   */
+  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;
+      }
+    });
+    
+    const avgCohesion = cohesionScores.reduce((sum, c) => sum + c, 0) / cohesionScores.length;
+    
+    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';
+  }
+
+  /**
+   * Calculate overall coupling
+   * @param {Array} boundaries - Array of boundaries
+   * @param {Array} relationships - Array of relationships
+   * @returns {string} - Coupling level
+   */
+  calculateOverallCoupling(boundaries, relationships) {
+    if (boundaries.length === 0) return 'unknown';
+    
+    const couplingScores = boundaries.map(b => {
+      const boundaryRelationships = relationships.filter(r => r.source === b.name);
+      if (boundaryRelationships.length === 0) return 5; // Very low coupling
+      
+      const avgStrength = boundaryRelationships.reduce((sum, r) => sum + r.strength, 0) / boundaryRelationships.length;
+      
+      if (avgStrength > 4) return 1; // Very high coupling
+      if (avgStrength > 3) return 2; // High coupling
+      if (avgStrength > 2) return 3; // Medium coupling
+      if (avgStrength > 1) return 4; // Low coupling
+      return 5; // Very low coupling
+    });
+    
+    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';
+  }
+
+  /**
+   * Generate refactoring recommendations
+   * @param {BoundaryDetectionResult} result - Detection result
+   * @returns {Array} - Array of recommendations
+   */
+  generateRefactoringRecommendations(result) {
+    const recommendations = [];
+    
+    // Add boundary-specific recommendations
+    const boundaryRecommendations = generateBoundaryRecommendations(result.boundaries);
+    recommendations.push(...boundaryRecommendations);
+    
+    // Add file-level recommendations
+    if (result.metadata.totalBoundaries > 20) {
+      recommendations.push({
+        type: 'file_structure',
+        priority: 'high',
+        message: 'File has too many boundaries (>20)',
+        action: 'split_into_modules'
+      });
+    }
+    
+    if (result.metadata.complexity === 'very_high') {
+      recommendations.push({
+        type: 'complexity',
+        priority: 'high',
+        message: 'File has very high complexity',
+        action: 'reduce_complexity'
+      });
+    }
+    
+    if (result.metadata.cohesion === 'very_low') {
+      recommendations.push({
+        type: 'cohesion',
+        priority: 'medium',
+        message: 'File has very low cohesion',
+        action: 'improve_cohesion'
+      });
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Export results to file
+   * @param {BoundaryDetectionResult} result - Detection result
+   * @param {string} outputPath - Output file path
+   * @returns {Promise<void>}
+   */
+  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');
+  }
+
+  /**
+   * Get detector information
+   * @returns {Object} - Detector info
+   */
+  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'
+    };
+  }
+
+  /**
+   * Create detector with default configuration
+   * @param {Object} config - Configuration overrides
+   * @returns {BoundaryDetector} - Detector instance
+   */
+  static createDefault(config = {}) {
+    return new BoundaryDetector({
+      includeComments: true,
+      includeImports: true,
+      includeExports: true,
+      minBoundarySize: 5,
+      analysisDepth: 'standard',
+      ...config
+    });
+  }
+
+  /**
+   * Create detector for refactoring
+   * @param {Object} config - Configuration overrides
+   * @returns {BoundaryDetector} - Refactoring detector instance
+   */
+  static createForRefactoring(config = {}) {
+    return new BoundaryDetector({
+      includeComments: false,
+      includeImports: true,
+      includeExports: true,
+      minBoundarySize: 10,
+      analysisDepth: 'deep',
+      ...config
+    });
+  }
+}
+
+module.exports = BoundaryDetector;