vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/refactoring/boundary-extraction-strategies.js

@@ -0,0 +1,330 @@
+/**
+ * Boundary Extraction Strategies
+ * 
+ * Contains methods for extracting different types of boundaries from code.
+ */
+
+const { BOUNDARY_TYPES } = require('./boundary-types');
+const ModuleBoundary = require('./module-boundary');
+
+/**
+ * Boundary extraction strategies class
+ */
+class BoundaryExtractionStrategies {
+  /**
+   * Extract function boundaries
+   */
+  static async extractFunctionBoundaries(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 = BoundaryExtractionStrategies.findFunctionBoundary(lines, i, funcMatch[1], result.filePath);
+        if (boundary) {
+          result.addBoundary(boundary);
+        }
+        continue;
+      }
+      
+      // Function expressions
+      const exprMatch = line.match(/^(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?function/);
+      if (exprMatch) {
+        const boundary = BoundaryExtractionStrategies.findFunctionBoundary(lines, i, exprMatch[1], result.filePath);
+        if (boundary) {
+          result.addBoundary(boundary);
+        }
+        continue;
+      }
+      
+      // Arrow functions
+      const arrowMatch = line.match(/^(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+      if (arrowMatch) {
+        const boundary = BoundaryExtractionStrategies.findArrowFunctionBoundary(lines, i, arrowMatch[1], result.filePath);
+        if (boundary) {
+          result.addBoundary(boundary);
+        }
+      }
+    }
+  }
+
+  /**
+   * Find function boundary
+   */
+  static findFunctionBoundary(lines, startLine, name, filePath) {
+    let braceCount = 0;
+    let foundBrace = false;
+    
+    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 ModuleBoundary(
+              BOUNDARY_TYPES.FUNCTION,
+              name,
+              startLine + 1,
+              i + 1,
+              filePath
+            );
+            return boundary;
+          }
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Find arrow function boundary
+   */
+  static findArrowFunctionBoundary(lines, startLine, name, filePath) {
+    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 ModuleBoundary(
+              BOUNDARY_TYPES.FUNCTION,
+              name,
+              startLine + 1,
+              i + 1,
+              filePath
+            );
+            return boundary;
+          }
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Extract class boundaries
+   */
+  static async extractClassBoundaries(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 = BoundaryExtractionStrategies.findClassBoundary(lines, i, classMatch[1], result.filePath);
+        if (boundary) {
+          result.addBoundary(boundary);
+        }
+      }
+    }
+  }
+
+  /**
+   * Find class boundary
+   */
+  static findClassBoundary(lines, startLine, name, filePath) {
+    let braceCount = 0;
+    let foundBrace = false;
+    
+    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) {
+            return new ModuleBoundary(
+              BOUNDARY_TYPES.CLASS,
+              name,
+              startLine + 1,
+              i + 1,
+              filePath
+            );
+          }
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Extract object boundaries
+   */
+  static async extractObjectBoundaries(lines, result) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Object assignments
+      const objMatch = line.match(/^(?:const|let|var)\s+(\w+)\s*=\s*\{/);
+      if (objMatch) {
+        const boundary = BoundaryExtractionStrategies.findObjectBoundary(lines, i, objMatch[1], result.filePath);
+        if (boundary) {
+          result.addBoundary(boundary);
+        }
+      }
+    }
+  }
+
+  /**
+   * Find object boundary
+   */
+  static findObjectBoundary(lines, startLine, name, filePath) {
+    let braceCount = 0;
+    let foundBrace = false;
+    
+    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 ModuleBoundary(
+              BOUNDARY_TYPES.OBJECT,
+              name,
+              startLine + 1,
+              i + 1,
+              filePath
+            );
+            return boundary;
+          }
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Extract utility boundaries
+   */
+  static async extractUtilityBoundaries(lines, result) {
+    // Look for utility sections marked by comments
+    let utilityStart = null;
+    let utilityName = null;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (line.startsWith('//') && (line.includes('utility') || line.includes('helper'))) {
+        if (utilityStart) {
+          // Close previous utility section
+          const boundary = new ModuleBoundary(
+            BOUNDARY_TYPES.UTILITY,
+            utilityName || 'utilities',
+            utilityStart,
+            i,
+            result.filePath
+          );
+          result.addBoundary(boundary);
+        }
+        
+        utilityStart = i + 1;
+        utilityName = line.replace('//', '').trim();
+      } else if (line.startsWith('//') && line.includes('end utility')) {
+        if (utilityStart) {
+          const boundary = new ModuleBoundary(
+            BOUNDARY_TYPES.UTILITY,
+            utilityName || 'utilities',
+            utilityStart,
+            i,
+            result.filePath
+          );
+          result.addBoundary(boundary);
+          utilityStart = null;
+          utilityName = null;
+        }
+      }
+    }
+    
+    // Close final utility section
+    if (utilityStart) {
+      const boundary = new ModuleBoundary(
+        BOUNDARY_TYPES.UTILITY,
+        utilityName || 'utilities',
+        utilityStart,
+        lines.length,
+        result.filePath
+      );
+      result.addBoundary(boundary);
+    }
+  }
+
+  /**
+   * Extract constant boundaries
+   */
+  static async extractConstantBoundaries(lines, result) {
+    // Look for constant blocks
+    const constants = [];
+    let constStart = null;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (line.startsWith('const ') && line.includes('=')) {
+        const match = line.match(/^const\s+(\w+)/);
+        if (match) {
+          constants.push({ name: match[1], line: i + 1 });
+          
+          if (constStart === null) {
+            constStart = i + 1;
+          }
+        }
+      } else if (constStart !== null && !line.startsWith('const ') && line.trim() !== '') {
+        // End of constant block
+        if (constants.length >= 3) { // Only extract if there are multiple constants
+          const boundary = new ModuleBoundary(
+            BOUNDARY_TYPES.CONSTANT,
+            'constants',
+            constStart,
+            i,
+            result.filePath
+          );
+          result.addBoundary(boundary);
+        }
+        
+        constants.length = 0;
+        constStart = null;
+      }
+    }
+    
+    // Close final constant block
+    if (constStart !== null && constants.length >= 3) {
+      const boundary = new ModuleBoundary(
+        BOUNDARY_TYPES.CONSTANT,
+        'constants',
+        constStart,
+        lines.length,
+        result.filePath
+      );
+      result.addBoundary(boundary);
+    }
+  }
+}
+
+module.exports = BoundaryExtractionStrategies;

package/src/refactoring/boundary-extractor.js

@@ -0,0 +1,384 @@
+/**
+ * Module Boundary Extractor
+ * 
+ * Main orchestrator for extracting logical module boundaries from files for refactoring.
+ * Identifies cohesive code segments that can be safely extracted.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { ModuleBoundary, BOUNDARY_TYPES, COHESION_LEVELS } = require('./boundaries/module-boundary');
+const {
+  FunctionExtractionStrategy,
+  ClassExtractionStrategy,
+  ObjectExtractionStrategy,
+  UtilityExtractionStrategy
+} = require('./boundaries/extraction-strategies');
+const CohesionAnalyzer = require('./boundaries/cohesion-analyzer');
+const BoundaryExtractionResult = require('./boundaries/extraction-result');
+
+/**
+ * Main Boundary Extractor class
+ */
+class BoundaryExtractor {
+  constructor(options = {}) {
+    this.options = {
+      minBoundarySize: options.minBoundarySize || 5,
+      maxBoundarySize: options.maxBoundarySize || 200,
+      includeStrategies: options.includeStrategies || ['function', 'class', 'object', 'utility'],
+      analyzeCohesion: options.analyzeCohesion !== false,
+      confidenceThreshold: options.confidenceThreshold || 0.6,
+      ...options
+    };
+
+    this.strategies = this.initializeStrategies();
+    this.cohesionAnalyzer = new CohesionAnalyzer();
+  }
+
+  /**
+   * Initialize extraction strategies
+   */
+  initializeStrategies() {
+    const strategyMap = {
+      function: new FunctionExtractionStrategy(),
+      class: new ClassExtractionStrategy(),
+      object: new ObjectExtractionStrategy(),
+      utility: new UtilityExtractionStrategy()
+    };
+
+    return Object.keys(strategyMap)
+      .filter(key => this.options.includeStrategies.includes(key))
+      .reduce((acc, key) => {
+        acc[key] = strategyMap[key];
+        return acc;
+      }, {});
+  }
+
+  /**
+   * Extract boundaries from a file
+   */
+  async extractBoundaries(filePath) {
+    const startTime = Date.now();
+    const result = new BoundaryExtractionResult(filePath);
+
+    try {
+      // Read file content
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+      
+      result.setMetadata('totalLines', lines.length);
+      result.setMetadata('processedLines', lines.length);
+
+      // Extract boundaries using all strategies
+      for (const [strategyName, strategy] of Object.entries(this.strategies)) {
+        if (strategy.canHandle(content)) {
+          try {
+            const boundaries = strategy.extract(content, filePath);
+            this.addBoundariesToResult(result, boundaries, strategyName);
+          } catch (error) {
+            result.addError({
+              message: `Strategy ${strategyName} failed: ${error.message}`,
+              severity: 'warning'
+            });
+          }
+        }
+      }
+
+      // Analyze cohesion for all boundaries
+      if (this.options.analyzeCohesion) {
+        await this.analyzeCohesionForBoundaries(result, content);
+      }
+
+      // Filter boundaries by size and confidence
+      this.filterBoundaries(result);
+
+      // Validate results
+      const issues = result.validate();
+      issues.forEach(issue => {
+        if (issue.type === 'overlap') {
+          result.addWarning({ message: issue.message, code: 'OVERLAP' });
+        }
+      });
+
+    } catch (error) {
+      result.addError({
+        message: `Failed to process file: ${error.message}`,
+        severity: 'error'
+      });
+    }
+
+    result.setMetadata('extractionTime', Date.now() - startTime);
+    return result;
+  }
+
+  /**
+   * Extract boundaries from multiple files
+   */
+  async extractBoundariesFromFiles(filePaths) {
+    const results = [];
+
+    for (const filePath of filePaths) {
+      try {
+        const result = await this.extractBoundaries(filePath);
+        results.push(result);
+      } catch (error) {
+        // Create error result
+        const errorResult = new BoundaryExtractionResult(filePath);
+        errorResult.addError({
+          message: `File processing failed: ${error.message}`,
+          severity: 'error'
+        });
+        results.push(errorResult);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Add boundaries to result
+   */
+  addBoundariesToResult(result, boundaries, strategyName) {
+    for (const boundaryData of boundaries) {
+      // Apply confidence threshold
+      if (boundaryData.confidence < this.options.confidenceThreshold) {
+        continue;
+      }
+
+      const boundary = result.addBoundary(boundaryData);
+      
+      // Add strategy metadata
+      boundary.extractionStrategy = strategyName;
+      boundary.confidence = boundaryData.confidence;
+    }
+  }
+
+  /**
+   * Analyze cohesion for all boundaries
+   */
+  async analyzeCohesionForBoundaries(result, content) {
+    for (const boundary of result.boundaries) {
+      try {
+        // Extract code segment for this boundary
+        const lines = content.split('\n');
+        const segmentLines = lines.slice(boundary.startLine - 1, boundary.endLine);
+        const segmentCode = segmentLines.join('\n');
+
+        // Analyze cohesion
+        const cohesion = this.cohesionAnalyzer.analyzeCohesion(segmentCode, boundary);
+        
+        boundary.setCohesion(cohesion.level);
+        boundary.cohesionScore = cohesion.score;
+        boundary.cohesionDetails = cohesion.details;
+
+      } catch (error) {
+        result.addWarning({
+          message: `Cohesion analysis failed for ${boundary.name}: ${error.message}`,
+          line: boundary.startLine
+        });
+      }
+    }
+  }
+
+  /**
+   * Filter boundaries based on criteria
+   */
+  filterBoundaries(result) {
+    result.boundaries = result.boundaries.filter(boundary => {
+      // Size filter
+      if (boundary.lineCount < this.options.minBoundarySize) {
+        return false;
+      }
+      if (boundary.lineCount > this.options.maxBoundarySize) {
+        return false;
+      }
+
+      // Name filter
+      if (!boundary.name || boundary.name.trim() === '') {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
+  /**
+   * Get extraction statistics for multiple results
+   */
+  getStatistics(results) {
+    const stats = {
+      totalFiles: results.length,
+      totalBoundaries: 0,
+      extractableBoundaries: 0,
+      highCohesionBoundaries: 0,
+      averageCoverage: 0,
+      byType: {},
+      errors: [],
+      warnings: [],
+      extractionTime: 0
+    };
+    
+    let totalCoverage = 0;
+    
+    for (const result of results) {
+      const resultStats = result.getStatistics();
+      
+      stats.totalBoundaries += resultStats.totalBoundaries;
+      stats.extractableBoundaries += resultStats.extractableBoundaries;
+      stats.highCohesionBoundaries += resultStats.highCohesionBoundaries;
+      totalCoverage += resultStats.coverage;
+      stats.extractionTime += result.metadata.extractionTime || 0;
+      
+      stats.errors.push(...result.errors);
+      stats.warnings.push(...result.warnings);
+      
+      // Count by type
+      for (const [type, count] of Object.entries(resultStats.typeDistribution)) {
+        stats.byType[type] = (stats.byType[type] || 0) + count;
+      }
+    }
+    
+    stats.averageCoverage = results.length > 0 ? totalCoverage / results.length : 0;
+    
+    return stats;
+  }
+
+  /**
+   * Get top extraction candidates across all results
+   */
+  getTopExtractionCandidates(results, limit = 20) {
+    const allCandidates = [];
+    
+    for (const result of results) {
+      const candidates = result.getTopExtractionCandidates(limit);
+      allCandidates.push(...candidates);
+    }
+
+    return allCandidates
+      .sort((a, b) => b.getExtractionPriority() - a.getExtractionPriority())
+      .slice(0, limit);
+  }
+
+  /**
+   * Generate extraction plan
+   */
+  generateExtractionPlan(results, options = {}) {
+    const candidates = this.getTopExtractionCandidates(results, options.limit || 50);
+    
+    return {
+      summary: this.getStatistics(results),
+      candidates: candidates.map(boundary => ({
+        ...boundary.getSummary(),
+        extractionPlan: this.generateBoundaryExtractionPlan(boundary)
+      })),
+      recommendations: this.generateRecommendations(results),
+      estimatedEffort: this.estimateExtractionEffort(candidates)
+    };
+  }
+
+  /**
+   * Generate extraction plan for a single boundary
+   */
+  generateBoundaryExtractionPlan(boundary) {
+    return {
+      targetFile: boundary.getSuggestedFilename(),
+      extractionSteps: [
+        `Create new file: ${boundary.getSuggestedFilename()}`,
+        `Extract lines ${boundary.startLine}-${boundary.endLine}`,
+        `Update imports in ${boundary.filePath}`,
+        `Add export statement to new file`,
+        `Test extraction and functionality`
+      ],
+      complexity: boundary.complexity,
+      estimatedTime: this.estimateBoundaryExtractionTime(boundary)
+    };
+  }
+
+  /**
+   * Generate recommendations
+   */
+  generateRecommendations(results) {
+    const stats = this.getStatistics(results);
+    const recommendations = [];
+
+    if (stats.extractableBoundaries === 0) {
+      recommendations.push('No extractable boundaries found. Consider adjusting extraction criteria.');
+    } else if (stats.extractableBoundaries < 5) {
+      recommendations.push('Few extractable boundaries found. Code may already be well-modularized.');
+    } else {
+      recommendations.push(`Found ${stats.extractableBoundaries} extractable boundaries. Prioritize high cohesion boundaries.`);
+    }
+
+    if (stats.averageCoverage < 30) {
+      recommendations.push('Low coverage suggests boundaries may be too small. Consider increasing minimum size.');
+    } else if (stats.averageCoverage > 80) {
+      recommendations.push('High coverage suggests boundaries may be too large. Consider decreasing maximum size.');
+    }
+
+    if (stats.highCohesionBoundaries / stats.extractableBoundaries < 0.5) {
+      recommendations.push('Many boundaries have low cohesion. Focus on improving code organization.');
+    }
+
+    return recommendations;
+  }
+
+  /**
+   * Estimate extraction effort
+   */
+  estimateExtractionEffort(candidates) {
+    let totalEffort = 0;
+
+    for (const boundary of candidates) {
+      totalEffort += this.estimateBoundaryExtractionTime(boundary);
+    }
+
+    return {
+      totalHours: totalEffort,
+      averageHoursPerBoundary: totalEffort / candidates.length,
+      complexityBreakdown: this.getComplexityBreakdown(candidates)
+    };
+  }
+
+  /**
+   * Estimate extraction time for a boundary
+   */
+  estimateBoundaryExtractionTime(boundary) {
+    let baseTime = 1; // 1 hour base
+
+    // Adjust for size
+    if (boundary.lineCount > 100) baseTime += 2;
+    else if (boundary.lineCount > 50) baseTime += 1;
+
+    // Adjust for complexity
+    if (boundary.complexity > 50) baseTime += 2;
+    else if (boundary.complexity > 20) baseTime += 1;
+
+    // Adjust for dependencies
+    baseTime += Math.min(boundary.dependencies.length * 0.5, 2);
+
+    return baseTime;
+  }
+
+  /**
+   * Get complexity breakdown
+   */
+  getComplexityBreakdown(candidates) {
+    const breakdown = { low: 0, medium: 0, high: 0 };
+
+    for (const boundary of candidates) {
+      if (boundary.complexity <= 20) breakdown.low++;
+      else if (boundary.complexity <= 50) breakdown.medium++;
+      else breakdown.high++;
+    }
+
+    return breakdown;
+  }
+}
+
+module.exports = {
+  BoundaryExtractor,
+  ModuleBoundary,
+  BoundaryExtractionResult,
+  BOUNDARY_TYPES,
+  COHESION_LEVELS
+};