vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

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

@@ -0,0 +1,554 @@
+/**
+ * Boundary Extraction Strategies
+ */
+
+const { BOUNDARY_TYPES } = require('./boundary-types');
+
+/**
+ * Extraction strategy base class
+ */
+class ExtractionStrategy {
+  constructor(name, description) {
+    this.name = name;
+    this.description = description;
+    this.priority = 'MEDIUM';
+  }
+
+  /**
+   * Check if strategy is applicable to boundary
+   * @param {Object} boundary - Boundary to check
+   * @returns {boolean} Whether strategy applies
+   */
+  isApplicable(boundary) {
+    return true; // Override in subclasses
+  }
+
+  /**
+   * Extract boundary to new module
+   * @param {Object} boundary - Boundary to extract
+   * @param {Array} lines - Source code lines
+   * @returns {Object} Extraction result
+   */
+  extract(boundary, lines) {
+    throw new Error('extract method must be implemented by subclasses');
+  }
+
+  /**
+   * Generate new file name for extracted boundary
+   * @param {Object} boundary - Boundary being extracted
+   * @returns {string} New file name
+   */
+  generateFileName(boundary) {
+    const baseName = boundary.name.toLowerCase()
+      .replace(/[^a-z0-9]/g, '-')
+      .replace(/-+/g, '-');
+    
+    return `${baseName}.js`;
+  }
+
+  /**
+   * Generate import statement for extracted module
+   * @param {Object} boundary - Boundary being extracted
+   * @param {string} fileName - New file name
+   * @returns {string} Import statement
+   */
+  generateImportStatement(boundary, fileName) {
+    const baseName = fileName.replace('.js', '');
+    
+    if (boundary.exports.length > 0) {
+      const exports = boundary.exports.join(', ');
+      return `import { ${exports} } from './${baseName}';\n`;
+    } else if (boundary.type === 'function' || boundary.type === 'class') {
+      return `import ${boundary.name} from './${baseName}';\n`;
+    }
+    
+    return '';
+  }
+
+  /**
+   * Generate export statement for extracted module
+   * @param {Object} boundary - Boundary being extracted
+   * @returns {string} Export statement
+   */
+  generateExportStatement(boundary) {
+    if (boundary.exports.length > 0) {
+      return `export { ${boundary.exports.join(', ')};`;
+    } else if (boundary.type === 'function' || boundary.type === 'class') {
+      return `export ${boundary.type === 'function' ? 'function ' : ''}${boundary.name};`;
+    }
+    
+    return '';
+  }
+
+  /**
+   * Update original file with extraction changes
+   * @param {Array} lines - Original file lines
+   * @param {Object} boundary - Boundary being extracted
+   * @param {string} importStatement - Import statement to add
+   * @returns {Array} Updated lines
+   */
+  updateOriginalFile(lines, boundary, importStatement) {
+    const updatedLines = [...lines];
+    
+    // Remove original boundary lines
+    updatedLines.splice(boundary.startLine - 1, boundary.lineCount);
+    
+    // Add import statement at original location
+    if (importStatement) {
+      updatedLines.splice(boundary.startLine - 1, 0, importStatement);
+    }
+    
+    return updatedLines;
+  }
+
+  /**
+   * Validate extraction result
+   * @param {Object} result - Extraction result
+   * @returns {Object} Validation result
+   */
+  validateExtraction(result) {
+    const errors = [];
+    
+    if (!result.extractedCode) {
+      errors.push('No extracted code generated');
+    }
+    
+    if (!result.fileName) {
+      errors.push('No file name generated');
+    }
+    
+    if (!result.originalCode) {
+      errors.push('Original code not preserved');
+    }
+    
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+}
+
+/**
+ * Standard extraction strategy
+ */
+class StandardExtractionStrategy extends ExtractionStrategy {
+  constructor() {
+    super('standard', 'Standard boundary extraction with imports and exports');
+    this.priority = 'HIGH';
+  }
+
+  isApplicable(boundary) {
+    return boundary.isExtractable() && 
+           boundary.lineCount >= 10 && 
+           boundary.lineCount <= 200;
+  }
+
+  extract(boundary, lines) {
+    const boundaryLines = lines.slice(boundary.startLine - 1, boundary.endLine);
+    const extractedCode = boundaryLines.join('\n');
+    
+    const fileName = this.generateFileName(boundary);
+    const importStatement = this.generateImportStatement(boundary, fileName);
+    const exportStatement = this.generateExportStatement(boundary);
+    
+    // Add export statement if needed
+    let finalExtractedCode = extractedCode;
+    if (exportStatement) {
+      finalExtractedCode += '\n\n' + exportStatement;
+    }
+    
+    const originalCode = lines.join('\n');
+    const updatedOriginalCode = this.updateOriginalFile(lines, boundary, importStatement);
+    
+    const result = {
+      strategy: this.name,
+      boundary,
+      fileName,
+      extractedCode: finalExtractedCode,
+      originalCode: updatedOriginalCode,
+      importStatement,
+      exportStatement,
+      dependencies: boundary.dependencies,
+      exports: boundary.exports
+    };
+    
+    const validation = this.validateExtraction(result);
+    if (!validation.isValid) {
+      throw new Error(`Extraction validation failed: ${validation.errors.join(', ')}`);
+    }
+    
+    return result;
+  }
+}
+
+/**
+ * Minimal extraction strategy
+ */
+class MinimalExtractionStrategy extends ExtractionStrategy {
+  constructor() {
+    super('minimal', 'Minimal extraction with no imports/exports');
+    this.priority = 'LOW';
+  }
+
+  isApplicable(boundary) {
+    return boundary.isExtractable() && 
+           boundary.lineCount <= 50;
+  }
+
+  extract(boundary, lines) {
+    const boundaryLines = lines.slice(boundary.startLine - 1, boundary.endLine);
+    const extractedCode = boundaryLines.join('\n');
+    
+    const fileName = this.generateFileName(boundary);
+    const originalCode = lines.join('\n');
+    const updatedOriginalCode = this.updateOriginalFile(lines, boundary, '');
+    
+    const result = {
+      strategy: this.name,
+      boundary,
+      fileName,
+      extractedCode,
+      originalCode: updatedOriginalCode,
+      dependencies: boundary.dependencies,
+      exports: []
+    };
+    
+    const validation = this.validateExtraction(result);
+    if (!validation.isValid) {
+      throw new Error(`Extraction validation failed: ${validation.errors.join(', ')}`);
+    }
+    
+    return result;
+  }
+}
+
+/**
+ * Class extraction strategy
+ */
+class ClassExtractionStrategy extends ExtractionStrategy {
+  constructor() {
+    super('class', 'Specialized extraction for classes');
+    this.priority = 'HIGH';
+  }
+
+  isApplicable(boundary) {
+    return boundary.type === BOUNDARY_TYPES.CLASS && 
+           boundary.isExtractable() && 
+           boundary.lineCount <= 300;
+  }
+
+  extract(boundary, lines) {
+    const boundaryLines = lines.slice(boundary.startLine - 1, boundary.endLine);
+    let extractedCode = boundaryLines.join('\n');
+    
+    const fileName = this.generateFileName(boundary);
+    const importStatement = this.generateImportStatement(boundary, fileName);
+    
+    // Ensure class is properly exported
+    if (!extractedCode.includes('export ')) {
+      extractedCode = `export ${extractedCode}`;
+    }
+    
+    const originalCode = lines.join('\n');
+    const updatedOriginalCode = this.updateOriginalFile(lines, boundary, importStatement);
+    
+    const result = {
+      strategy: this.name,
+      boundary,
+      fileName,
+      extractedCode,
+      originalCode: updatedOriginalCode,
+      importStatement,
+      dependencies: boundary.dependencies,
+      exports: boundary.exports
+    };
+    
+    const validation = this.validateExtraction(result);
+    if (!validation.isValid) {
+      throw new Error(`Extraction validation failed: ${validation.errors.join(', ')}`);
+    }
+    
+    return result;
+  }
+}
+
+/**
+ * Utility extraction strategy
+ */
+class UtilityExtractionStrategy extends ExtractionStrategy {
+  constructor() {
+    super('utility', 'Specialized extraction for utility functions');
+    this.priority = 'MEDIUM';
+  }
+
+  isApplicable(boundary) {
+    return boundary.type === BOUNDARY_TYPES.UTILITY && 
+           boundary.isExtractable() && 
+           boundary.lineCount <= 100;
+  }
+
+  extract(boundary, lines) {
+    const boundaryLines = lines.slice(boundary.startLine - 1, boundary.endLine);
+    let extractedCode = boundaryLines.join('\n');
+    
+    const fileName = this.generateFileName(boundary);
+    const importStatement = this.generateImportStatement(boundary, fileName);
+    
+    // Ensure utility function is exported
+    if (!extractedCode.includes('export ')) {
+      extractedCode = `export ${extractedCode}`;
+    }
+    
+    const originalCode = lines.join('\n');
+    const updatedOriginalCode = this.updateOriginalFile(lines, boundary, importStatement);
+    
+    const result = {
+      strategy: this.name,
+      boundary,
+      fileName,
+      extractedCode,
+      originalCode: updatedOriginalCode,
+      importStatement,
+      dependencies: boundary.dependencies,
+      exports: boundary.exports
+    };
+    
+    const validation = this.validateExtraction(result);
+    if (!validation.isValid) {
+      throw new Error(`Extraction validation failed: ${validation.errors.join(', ')}`);
+    }
+    
+    return result;
+  }
+}
+
+/**
+ * Strategy selector
+ */
+class StrategySelector {
+  constructor() {
+    this.strategies = [
+      new StandardExtractionStrategy(),
+      new ClassExtractionStrategy(),
+      new UtilityExtractionStrategy(),
+      new MinimalExtractionStrategy()
+    ];
+  }
+
+  /**
+   * Select best strategy for boundary
+   * @param {Object} boundary - Boundary to extract
+   * @returns {ExtractionStrategy|null} Selected strategy
+   */
+  selectStrategy(boundary) {
+    const applicableStrategies = this.strategies.filter(strategy => 
+      strategy.isApplicable(boundary)
+    );
+    
+    if (applicableStrategies.length === 0) {
+      return null;
+    }
+    
+    // Sort by priority (HIGH > MEDIUM > LOW)
+    applicableStrategies.sort((a, b) => {
+      const priorityOrder = { HIGH: 3, MEDIUM: 2, LOW: 1 };
+      return priorityOrder[b.priority] - priorityOrder[a.priority];
+    });
+    
+    return applicableStrategies[0];
+  }
+
+  /**
+   * Get all strategies
+   * @returns {Array} All strategies
+   */
+  getAllStrategies() {
+    return [...this.strategies];
+  }
+
+  /**
+   * Add custom strategy
+   * @param {ExtractionStrategy} strategy - Custom strategy to add
+   */
+  addStrategy(strategy) {
+    if (strategy instanceof ExtractionStrategy) {
+      this.strategies.push(strategy);
+    }
+  }
+
+  /**
+   * Remove strategy
+   * @param {string} strategyName - Name of strategy to remove
+   */
+  removeStrategy(strategyName) {
+    this.strategies = this.strategies.filter(s => s.name !== strategyName);
+  }
+
+  /**
+   * Get strategy by name
+   * @param {string} strategyName - Name of strategy
+   * @returns {ExtractionStrategy|null} Strategy or null
+   */
+  getStrategy(strategyName) {
+    return this.strategies.find(s => s.name === strategyName) || null;
+  }
+}
+
+/**
+ * Extraction orchestrator
+ */
+class ExtractionOrchestrator {
+  constructor() {
+    this.strategySelector = new StrategySelector();
+  }
+
+  /**
+   * Extract boundary using best available strategy
+   * @param {Object} boundary - Boundary to extract
+   * @param {Array} lines - Source code lines
+   * @returns {Object} Extraction result
+   */
+  extract(boundary, lines) {
+    const strategy = this.strategySelector.selectStrategy(boundary);
+    
+    if (!strategy) {
+      throw new Error(`No applicable extraction strategy found for boundary: ${boundary.name}`);
+    }
+    
+    console.log(`Using ${strategy.name} strategy for ${boundary.name} boundary`);
+    
+    return strategy.extract(boundary, lines);
+  }
+
+  /**
+   * Extract multiple boundaries
+   * @param {Array} boundaries - Boundaries to extract
+   * @param {Array} lines - Source code lines
+   * @returns {Array} Array of extraction results
+   */
+  extractMultiple(boundaries, lines) {
+    const results = [];
+    
+    // Sort boundaries by priority (extractable, then by score)
+    const sortedBoundaries = boundaries
+      .filter(b => b.isExtractable())
+      .sort((a, b) => b.calculateScore() - a.calculateScore());
+    
+    for (const boundary of sortedBoundaries) {
+      try {
+        const result = this.extract(boundary, lines);
+        results.push(result);
+      } catch (error) {
+        console.warn(`Failed to extract boundary ${boundary.name}:`, error.message);
+        // Continue with other boundaries
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Plan extraction for multiple boundaries
+   * @param {Array} boundaries - Boundaries to extract
+   * @returns {Object} Extraction plan
+   */
+  planExtraction(boundaries) {
+    const extractable = boundaries.filter(b => b.isExtractable());
+    const strategyMap = new Map();
+    
+    // Select strategies for each boundary
+    for (const boundary of extractable) {
+      const strategy = this.strategySelector.selectStrategy(boundary);
+      if (strategy) {
+        strategyMap.set(boundary.id, strategy);
+      }
+    }
+    
+    // Group boundaries by strategy
+    const strategyGroups = new Map();
+    for (const [boundaryId, strategy] of strategyMap) {
+      if (!strategyGroups.has(strategy.name)) {
+        strategyGroups.set(strategy.name, []);
+      }
+      strategyGroups.get(strategy.name).push(boundaryId);
+    }
+    
+    // Generate extraction plan
+    const plan = {
+      totalBoundaries: extractable.length,
+      strategyGroups: Array.from(strategyGroups.entries()).map(([strategy, boundaryIds]) => ({
+        strategy,
+        boundaries: boundaryIds.map(id => extractable.find(b => b.id === id)),
+        count: boundaryIds.length
+      })),
+      estimatedEffort: this.estimateEffort(extractable),
+      dependencies: this.analyzeDependencies(extractable)
+    };
+    
+    return plan;
+  }
+
+  /**
+   * Estimate extraction effort
+   * @param {Array} boundaries - Boundaries to extract
+   * @returns {string} Effort estimate
+   */
+  estimateEffort(boundaries) {
+    const totalLines = boundaries.reduce((sum, b) => sum + b.lineCount, 0);
+    const hours = Math.round(totalLines / 50); // Rough estimate
+    
+    if (hours <= 2) return 'Low';
+    if (hours <= 8) return 'Medium';
+    if (hours <= 20) return 'High';
+    return 'Very High';
+  }
+
+  /**
+   * Analyze dependencies between boundaries
+   * @param {Array} boundaries - Boundaries to analyze
+   * @returns {Object} Dependency analysis
+   */
+  analyzeDependencies(boundaries) {
+    const allDependencies = new Set();
+    const internalDependencies = new Map();
+    
+    for (const boundary of boundaries) {
+      for (const dep of boundary.dependencies) {
+        allDependencies.add(dep);
+        
+        // Check if dependency is internal (from another boundary)
+        const dependentBoundary = boundaries.find(b => 
+          b.exports.includes(dep) || b.name === dep
+        );
+        
+        if (dependentBoundary) {
+          if (!internalDependencies.has(boundary.id)) {
+            internalDependencies.set(boundary.id, []);
+          }
+          internalDependencies.get(boundary.id).push(dependentBoundary.id);
+        }
+      }
+    }
+    
+    return {
+      totalDependencies: allDependencies.size,
+      internalDependencies: Array.from(internalDependencies.entries()).map(([id, deps]) => ({
+        boundaryId: id,
+        dependencies: deps
+      })),
+      externalDependencies: Array.from(allDependencies).filter(dep => 
+        !boundaries.some(b => b.exports.includes(dep) || b.name === dep)
+      )
+    };
+  }
+}
+
+module.exports = {
+  ExtractionStrategy,
+  StandardExtractionStrategy,
+  MinimalExtractionStrategy,
+  ClassExtractionStrategy,
+  UtilityExtractionStrategy,
+  StrategySelector,
+  ExtractionOrchestrator
+};

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

@@ -0,0 +1,77 @@
+/**
+ * Boundary Extraction Result Class
+ * 
+ * Represents the result of boundary extraction from a file.
+ */
+
+const { COHESION_LEVELS } = require('./boundary-types');
+
+/**
+ * Boundary extraction result class
+ */
+class BoundaryExtractionResult {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.boundaries = [];
+    this.metadata = {
+      extractedAt: new Date().toISOString(),
+      totalLines: 0,
+      coverage: 0
+    };
+    this.errors = [];
+    this.warnings = [];
+  }
+
+  addBoundary(boundary) {
+    this.boundaries.push(boundary);
+  }
+
+  addError(error) {
+    this.errors.push({
+      message: error.message,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  addWarning(warning) {
+    this.warnings.push({
+      message: warning,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  getBoundariesByType(type) {
+    return this.boundaries.filter(b => b.type === type);
+  }
+
+  getExtractableBoundaries() {
+    return this.boundaries.filter(b => b.metadata.extractable);
+  }
+
+  getHighCohesionBoundaries() {
+    return this.boundaries.filter(b => b.cohesion === COHESION_LEVELS.HIGH);
+  }
+
+  calculateCoverage() {
+    if (this.metadata.totalLines === 0) return 0;
+    
+    const coveredLines = this.boundaries.reduce((sum, b) => sum + b.lineCount, 0);
+    this.metadata.coverage = (coveredLines / this.metadata.totalLines) * 100;
+    
+    return this.metadata.coverage;
+  }
+
+  getSummary() {
+    return {
+      filePath: this.filePath,
+      boundaryCount: this.boundaries.length,
+      extractableCount: this.getExtractableBoundaries().length,
+      highCohesionCount: this.getHighCohesionBoundaries().length,
+      coverage: this.calculateCoverage(),
+      errorCount: this.errors.length,
+      warningCount: this.warnings.length
+    };
+  }
+}
+
+module.exports = BoundaryExtractionResult;