vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/analysis/strategy-generator.js

@@ -0,0 +1,814 @@
+/**
+ * Refactoring Strategy Generator
+ * 
+ * Generates comprehensive refactoring strategies based on analysis results.
+ * Provides prioritized, actionable refactoring plans.
+ */
+
+const path = require('path');
+const RefactoringConfig = require('../config/refactoring-config');
+
+/**
+ * Strategy types
+ */
+const STRATEGY_TYPES = {
+  SPLIT_FILE: 'split_file',
+  EXTRACT_FUNCTIONS: 'extract_functions',
+  EXTRACT_CLASSES: 'extract_classes',
+  EXTRACT_UTILITIES: 'extract_utilities',
+  EXTRACT_CONSTANTS: 'extract_constants',
+  REORGANIZE_IMPORTS: 'reorganize_imports',
+  MERGE_SMALL_FILES: 'merge_small_files',
+  RESTRUCTURE_DIRECTORIES: 'restructure_directories',
+  OPTIMIZE_DEPENDENCIES: 'optimize_dependencies'
+};
+
+/**
+ * Priority levels
+ */
+const PRIORITY_LEVELS = {
+  CRITICAL: 'critical',
+  HIGH: 'high',
+  MEDIUM: 'medium',
+  LOW: 'low'
+};
+
+/**
+ * Refactoring strategy class
+ */
+class RefactoringStrategy {
+  constructor(type, targetPath, priority = PRIORITY_LEVELS.MEDIUM) {
+    this.id = this.generateId();
+    this.type = type;
+    this.targetPath = targetPath;
+    this.priority = priority;
+    this.description = '';
+    this.steps = [];
+    this.estimatedEffort = 0;
+    this.riskLevel = 'medium';
+    this.dependencies = [];
+    this.impact = {
+      files: [],
+      lines: 0,
+      complexity: 'unknown'
+    };
+    this.metadata = {
+      createdAt: new Date().toISOString(),
+      status: 'pending'
+    };
+  }
+
+  generateId() {
+    return `strategy_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  addStep(step) {
+    this.steps.push(step);
+  }
+
+  addDependency(dependency) {
+    this.dependencies.push(dependency);
+  }
+
+  setEstimatedEffort(effort) {
+    this.estimatedEffort = effort;
+  }
+
+  setRiskLevel(risk) {
+    this.riskLevel = risk;
+  }
+
+  setImpact(impact) {
+    this.impact = { ...this.impact, ...impact };
+  }
+}
+
+/**
+ * Strategy generator class
+ */
+class StrategyGenerator {
+  constructor(config = RefactoringConfig) {
+    this.config = config;
+    this.strategies = [];
+    this.analysisResults = null;
+  }
+
+  /**
+   * Generate strategies based on analysis results
+   */
+  generateStrategies(analysisResults) {
+    this.analysisResults = analysisResults;
+    this.strategies = [];
+
+    // Generate strategies for each file that needs refactoring
+    for (const fileAnalysis of analysisResults.files || []) {
+      if (fileAnalysis.needsRefactoring || fileAnalysis.urgentRefactoring) {
+        const fileStrategies = this.generateFileStrategies(fileAnalysis);
+        this.strategies.push(...fileStrategies);
+      }
+    }
+
+    // Generate global strategies
+    const globalStrategies = this.generateGlobalStrategies();
+    this.strategies.push(...globalStrategies);
+
+    // Prioritize strategies
+    this.prioritizeStrategies();
+
+    return this.strategies;
+  }
+
+  /**
+   * Generate strategies for a specific file
+   */
+  generateFileStrategies(fileAnalysis) {
+    const strategies = [];
+    const { filePath, lineCount, categorization, boundaries } = fileAnalysis;
+
+    // Determine priority based on file analysis
+    const priority = this.determinePriority(fileAnalysis);
+
+    // Large file splitting strategy
+    if (lineCount > 555) {
+      const splitStrategy = this.generateSplitFileStrategy(fileAnalysis, priority);
+      strategies.push(splitStrategy);
+    }
+
+    // Function extraction strategies
+    if (boundaries && boundaries.functions) {
+      const largeFunctions = boundaries.functions.filter(f => f.lineCount > 30);
+      if (largeFunctions.length > 0) {
+        const extractStrategy = this.generateExtractFunctionsStrategy(fileAnalysis, largeFunctions, priority);
+        strategies.push(extractStrategy);
+      }
+    }
+
+    // Class extraction strategies
+    if (boundaries && boundaries.classes) {
+      const largeClasses = boundaries.classes.filter(c => c.lineCount > 150);
+      if (largeClasses.length > 0) {
+        const extractStrategy = this.generateExtractClassesStrategy(fileAnalysis, largeClasses, priority);
+        strategies.push(extractStrategy);
+      }
+    }
+
+    // Utility extraction strategy
+    if (boundaries && boundaries.utilities && boundaries.utilities.length > 0) {
+      const utilityStrategy = this.generateExtractUtilitiesStrategy(fileAnalysis, priority);
+      strategies.push(utilityStrategy);
+    }
+
+    // Import reorganization strategy
+    if (boundaries && boundaries.imports && boundaries.imports.length > 10) {
+      const importStrategy = this.generateReorganizeImportsStrategy(fileAnalysis, priority);
+      strategies.push(importStrategy);
+    }
+
+    return strategies;
+  }
+
+  /**
+   * Generate split file strategy
+   */
+  generateSplitFileStrategy(fileAnalysis, priority) {
+    const strategy = new RefactoringStrategy(
+      STRATEGY_TYPES.SPLIT_FILE,
+      fileAnalysis.filePath,
+      priority
+    );
+
+    strategy.description = `Split large file (${fileAnalysis.lineCount} lines) into smaller, focused modules`;
+
+    // Determine split points based on boundaries
+    const splitPoints = this.identifySplitPoints(fileAnalysis);
+    
+    strategy.addStep({
+      action: 'analyze_boundaries',
+      description: 'Analyze file structure to identify logical split points',
+      command: 'analyze-boundaries',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'create_backup',
+      description: 'Create backup of original file',
+      command: 'backup-file',
+      target: fileAnalysis.filePath
+    });
+
+    for (let i = 0; i < splitPoints.length; i++) {
+      const point = splitPoints[i];
+      strategy.addStep({
+        action: 'extract_module',
+        description: `Extract ${point.type} "${point.name}" to separate file`,
+        command: 'extract-module',
+        target: fileAnalysis.filePath,
+        output: point.suggestedPath,
+        lines: `${point.startLine}-${point.endLine}`
+      });
+    }
+
+    strategy.addStep({
+      action: 'update_imports',
+      description: 'Update import statements in dependent files',
+      command: 'update-imports',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'validate_refactoring',
+      description: 'Run tests to validate refactoring',
+      command: 'run-tests',
+      target: 'all'
+    });
+
+    strategy.addStep({
+      action: 'cleanup_original',
+      description: 'Clean up original file (remove extracted code)',
+      command: 'cleanup-file',
+      target: fileAnalysis.filePath
+    });
+
+    // Estimate effort
+    strategy.setEstimatedEffort(this.estimateSplitEffort(fileAnalysis, splitPoints));
+    strategy.setRiskLevel(this.assessSplitRisk(fileAnalysis));
+    strategy.setImpact({
+      files: [fileAnalysis.filePath, ...splitPoints.map(p => p.suggestedPath)],
+      lines: fileAnalysis.lineCount,
+      complexity: 'high'
+    });
+
+    return strategy;
+  }
+
+  /**
+   * Generate extract functions strategy
+   */
+  generateExtractFunctionsStrategy(fileAnalysis, largeFunctions, priority) {
+    const strategy = new RefactoringStrategy(
+      STRATEGY_TYPES.EXTRACT_FUNCTIONS,
+      fileAnalysis.filePath,
+      priority
+    );
+
+    strategy.description = `Extract ${largeFunctions.length} large functions to separate utility modules`;
+
+    strategy.addStep({
+      action: 'analyze_functions',
+      description: 'Analyze function dependencies and usage',
+      command: 'analyze-functions',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'create_backup',
+      description: 'Create backup of original file',
+      command: 'backup-file',
+      target: fileAnalysis.filePath
+    });
+
+    for (const func of largeFunctions) {
+      strategy.addStep({
+        action: 'extract_function',
+        description: `Extract function "${func.name}" to utility module`,
+        command: 'extract-function',
+        target: fileAnalysis.filePath,
+        functionName: func.name,
+        lines: `${func.startLine}-${func.endLine}`,
+        output: this.suggestUtilityPath(fileAnalysis.filePath, func.name)
+      });
+    }
+
+    strategy.addStep({
+      action: 'update_function_calls',
+      description: 'Update function calls and imports',
+      command: 'update-calls',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'validate_extraction',
+      description: 'Run tests to validate function extraction',
+      command: 'run-tests',
+      target: 'all'
+    });
+
+    strategy.setEstimatedEffort(largeFunctions.length * 2); // 2 effort units per function
+    strategy.setRiskLevel('medium');
+    strategy.setImpact({
+      files: [fileAnalysis.filePath],
+      lines: largeFunctions.reduce((sum, f) => sum + f.lineCount, 0),
+      complexity: 'medium'
+    });
+
+    return strategy;
+  }
+
+  /**
+   * Generate extract classes strategy
+   */
+  generateExtractClassesStrategy(fileAnalysis, largeClasses, priority) {
+    const strategy = new RefactoringStrategy(
+      STRATEGY_TYPES.EXTRACT_CLASSES,
+      fileAnalysis.filePath,
+      priority
+    );
+
+    strategy.description = `Extract ${largeClasses.length} large classes to separate modules`;
+
+    strategy.addStep({
+      action: 'analyze_classes',
+      description: 'Analyze class dependencies and inheritance',
+      command: 'analyze-classes',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'create_backup',
+      description: 'Create backup of original file',
+      command: 'backup-file',
+      target: fileAnalysis.filePath
+    });
+
+    for (const cls of largeClasses) {
+      strategy.addStep({
+        action: 'extract_class',
+        description: `Extract class "${cls.name}" to separate module`,
+        command: 'extract-class',
+        target: fileAnalysis.filePath,
+        className: cls.name,
+        lines: `${cls.startLine}-${cls.endLine}`,
+        output: this.suggestClassPath(fileAnalysis.filePath, cls.name)
+      });
+    }
+
+    strategy.addStep({
+      action: 'update_class_references',
+      description: 'Update class references and imports',
+      command: 'update-references',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'validate_extraction',
+      description: 'Run tests to validate class extraction',
+      command: 'run-tests',
+      target: 'all'
+    });
+
+    strategy.setEstimatedEffort(largeClasses.length * 3); // 3 effort units per class
+    strategy.setRiskLevel('high');
+    strategy.setImpact({
+      files: [fileAnalysis.filePath],
+      lines: largeClasses.reduce((sum, c) => sum + c.lineCount, 0),
+      complexity: 'high'
+    });
+
+    return strategy;
+  }
+
+  /**
+   * Generate extract utilities strategy
+   */
+  generateExtractUtilitiesStrategy(fileAnalysis, priority) {
+    const strategy = new RefactoringStrategy(
+      STRATEGY_TYPES.EXTRACT_UTILITIES,
+      fileAnalysis.filePath,
+      priority
+    );
+
+    strategy.description = 'Extract utility functions and constants to separate modules';
+
+    strategy.addStep({
+      action: 'identify_utilities',
+      description: 'Identify utility functions and constants',
+      command: 'identify-utilities',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'create_backup',
+      description: 'Create backup of original file',
+      command: 'backup-file',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'extract_utilities',
+      description: 'Extract utilities to utility modules',
+      command: 'extract-utilities',
+      target: fileAnalysis.filePath,
+      output: this.suggestUtilityPath(fileAnalysis.filePath, 'utils')
+    });
+
+    strategy.addStep({
+      action: 'update_utility_imports',
+      description: 'Update utility imports and references',
+      command: 'update-imports',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'validate_extraction',
+      description: 'Run tests to validate utility extraction',
+      command: 'run-tests',
+      target: 'all'
+    });
+
+    strategy.setEstimatedEffort(2);
+    strategy.setRiskLevel('low');
+    strategy.setImpact({
+      files: [fileAnalysis.filePath],
+      lines: 0, // Depends on analysis
+      complexity: 'low'
+    });
+
+    return strategy;
+  }
+
+  /**
+   * Generate reorganize imports strategy
+   */
+  generateReorganizeImportsStrategy(fileAnalysis, priority) {
+    const strategy = new RefactoringStrategy(
+      STRATEGY_TYPES.REORGANIZE_IMPORTS,
+      fileAnalysis.filePath,
+      priority
+    );
+
+    strategy.description = 'Reorganize and optimize import statements';
+
+    strategy.addStep({
+      action: 'analyze_imports',
+      description: 'Analyze import structure and dependencies',
+      command: 'analyze-imports',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'create_backup',
+      description: 'Create backup of original file',
+      command: 'backup-file',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'reorganize_imports',
+      description: 'Reorganize imports by type and source',
+      command: 'reorganize-imports',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'remove_unused_imports',
+      description: 'Remove unused import statements',
+      command: 'remove-unused-imports',
+      target: fileAnalysis.filePath
+    });
+
+    strategy.addStep({
+      action: 'validate_reorganization',
+      description: 'Run tests to validate import reorganization',
+      command: 'run-tests',
+      target: 'all'
+    });
+
+    strategy.setEstimatedEffort(1);
+    strategy.setRiskLevel('low');
+    strategy.setImpact({
+      files: [fileAnalysis.filePath],
+      lines: 0,
+      complexity: 'low'
+    });
+
+    return strategy;
+  }
+
+  /**
+   * Generate global strategies
+   */
+  generateGlobalStrategies() {
+    const strategies = [];
+
+    // Merge small files strategy
+    const smallFilesStrategy = this.generateMergeSmallFilesStrategy();
+    if (smallFilesStrategy) {
+      strategies.push(smallFilesStrategy);
+    }
+
+    // Directory restructuring strategy
+    const restructureStrategy = this.generateRestructureDirectoriesStrategy();
+    if (restructureStrategy) {
+      strategies.push(restructureStrategy);
+    }
+
+    // Dependency optimization strategy
+    const optimizeStrategy = this.generateOptimizeDependenciesStrategy();
+    if (optimizeStrategy) {
+      strategies.push(optimizeStrategy);
+    }
+
+    return strategies;
+  }
+
+  /**
+   * Generate merge small files strategy
+   */
+  generateMergeSmallFilesStrategy() {
+    const smallFiles = this.findSmallFiles();
+    
+    if (smallFiles.length < 2) {
+      return null;
+    }
+
+    const strategy = new RefactoringStrategy(
+      STRATEGY_TYPES.MERGE_SMALL_FILES,
+      'multiple',
+      PRIORITY_LEVELS.LOW
+    );
+
+    strategy.description = `Merge ${smallFiles.length} small files into cohesive modules`;
+
+    // Group small files by package and type
+    const fileGroups = this.groupSmallFiles(smallFiles);
+
+    for (const [groupKey, files] of Object.entries(fileGroups)) {
+      strategy.addStep({
+        action: 'merge_files',
+        description: `Merge ${files.length} small files in ${groupKey}`,
+        command: 'merge-files',
+        target: files.map(f => f.path),
+        output: this.suggestMergedPath(files)
+      });
+    }
+
+    strategy.setEstimatedEffort(fileGroups.length * 2);
+    strategy.setRiskLevel('medium');
+    strategy.setImpact({
+      files: smallFiles.map(f => f.path),
+      lines: smallFiles.reduce((sum, f) => sum + f.lineCount, 0),
+      complexity: 'medium'
+    });
+
+    return strategy;
+  }
+
+  /**
+   * Generate restructure directories strategy
+   */
+  generateRestructureDirectoriesStrategy() {
+    // This would analyze directory structure and suggest improvements
+    // For now, return null as it's complex to implement
+    return null;
+  }
+
+  /**
+   * Generate optimize dependencies strategy
+   */
+  generateOptimizeDependenciesStrategy() {
+    // This would analyze dependencies and suggest optimizations
+    // For now, return null as it's complex to implement
+    return null;
+  }
+
+  /**
+   * Identify split points in a file
+   */
+  identifySplitPoints(fileAnalysis) {
+    const splitPoints = [];
+    const { boundaries } = fileAnalysis;
+
+    if (!boundaries) return splitPoints;
+
+    // Add large functions as split points
+    if (boundaries.functions) {
+      for (const func of boundaries.functions.filter(f => f.lineCount > 30)) {
+        splitPoints.push({
+          type: 'function',
+          name: func.name,
+          startLine: func.startLine,
+          endLine: func.endLine,
+          suggestedPath: this.suggestFunctionPath(fileAnalysis.filePath, func.name)
+        });
+      }
+    }
+
+    // Add large classes as split points
+    if (boundaries.classes) {
+      for (const cls of boundaries.classes.filter(c => c.lineCount > 100)) {
+        splitPoints.push({
+          type: 'class',
+          name: cls.name,
+          startLine: cls.startLine,
+          endLine: cls.endLine,
+          suggestedPath: this.suggestClassPath(fileAnalysis.filePath, cls.name)
+        });
+      }
+    }
+
+    // Add utility sections as split points
+    if (boundaries.utilities) {
+      for (const util of boundaries.utilities) {
+        splitPoints.push({
+          type: 'utility',
+          name: util.name,
+          startLine: util.startLine,
+          endLine: util.endLine,
+          suggestedPath: this.suggestUtilityPath(fileAnalysis.filePath, 'utils')
+        });
+      }
+    }
+
+    return splitPoints.sort((a, b) => a.startLine - b.startLine);
+  }
+
+  /**
+   * Suggest path for extracted function
+   */
+  suggestFunctionPath(originalPath, functionName) {
+    const dir = path.dirname(originalPath);
+    const name = functionName.toLowerCase();
+    return path.join(dir, `${name}.js`);
+  }
+
+  /**
+   * Suggest path for extracted class
+   */
+  suggestClassPath(originalPath, className) {
+    const dir = path.dirname(originalPath);
+    const name = className.toLowerCase();
+    return path.join(dir, `${name}.js`);
+  }
+
+  /**
+   * Suggest path for utilities
+   */
+  suggestUtilityPath(originalPath, utilityName) {
+    const dir = path.dirname(originalPath);
+    return path.join(dir, `${utilityName}.js`);
+  }
+
+  /**
+   * Suggest path for merged files
+   */
+  suggestMergedPath(files) {
+    const dir = path.dirname(files[0].path);
+    const name = 'merged-' + path.basename(files[0].path, '.js');
+    return path.join(dir, `${name}.js`);
+  }
+
+  /**
+   * Determine priority for file analysis
+   */
+  determinePriority(fileAnalysis) {
+    if (fileAnalysis.urgentRefactoring || fileAnalysis.lineCount > 800) {
+      return PRIORITY_LEVELS.CRITICAL;
+    }
+    if (fileAnalysis.needsRefactoring || fileAnalysis.lineCount > 555) {
+      return PRIORITY_LEVELS.HIGH;
+    }
+    if (fileAnalysis.lineCount > 300) {
+      return PRIORITY_LEVELS.MEDIUM;
+    }
+    return PRIORITY_LEVELS.LOW;
+  }
+
+  /**
+   * Estimate effort for file splitting
+   */
+  estimateSplitEffort(fileAnalysis, splitPoints) {
+    const baseEffort = 5; // Base effort for any split
+    const splitEffort = splitPoints.length * 2; // 2 effort per split point
+    const sizeEffort = Math.ceil(fileAnalysis.lineCount / 100); // 1 effort per 100 lines
+    
+    return baseEffort + splitEffort + sizeEffort;
+  }
+
+  /**
+   * Assess risk of file splitting
+   */
+  assessSplitRisk(fileAnalysis) {
+    let risk = 'medium';
+    
+    if (fileAnalysis.lineCount > 1000) {
+      risk = 'high';
+    } else if (fileAnalysis.lineCount < 300) {
+      risk = 'low';
+    }
+    
+    // Consider complexity
+    if (fileAnalysis.categorization && fileAnalysis.categorization.complexity === 'VERY_COMPLEX') {
+      risk = 'high';
+    } else if (fileAnalysis.categorization && fileAnalysis.categorization.complexity === 'SIMPLE') {
+      risk = 'low';
+    }
+    
+    return risk;
+  }
+
+  /**
+   * Find small files that could be merged
+   */
+  findSmallFiles() {
+    if (!this.analysisResults || !this.analysisResults.files) {
+      return [];
+    }
+
+    return this.analysisResults.files.filter(file => 
+      file.lineCount < 50 && file.lineCount > 5 // Not too small
+    );
+  }
+
+  /**
+   * Group small files for merging
+   */
+  groupSmallFiles(smallFiles) {
+    const groups = {};
+    
+    for (const file of smallFiles) {
+      const pkg = this.extractPackage(file.path);
+      const type = this.extractFileType(file.path);
+      const key = `${pkg}/${type}`;
+      
+      if (!groups[key]) {
+        groups[key] = [];
+      }
+      groups[key].push(file);
+    }
+
+    return groups;
+  }
+
+  /**
+   * Extract package from file path
+   */
+  extractPackage(filePath) {
+    const match = filePath.match(/packages\/([^\/]+)/);
+    return match ? match[1] : 'root';
+  }
+
+  /**
+   * Extract file type from path
+   */
+  extractFileType(filePath) {
+    const basename = path.basename(filePath, path.extname(filePath));
+    return basename.includes('test') ? 'test' : 
+           basename.includes('util') ? 'utility' : 'main';
+  }
+
+  /**
+   * Prioritize strategies
+   */
+  prioritizeStrategies() {
+    const priorityOrder = {
+      [PRIORITY_LEVELS.CRITICAL]: 0,
+      [PRIORITY_LEVELS.HIGH]: 1,
+      [PRIORITY_LEVELS.MEDIUM]: 2,
+      [PRIORITY_LEVELS.LOW]: 3
+    };
+
+    this.strategies.sort((a, b) => {
+      return priorityOrder[a.priority] - priorityOrder[b.priority];
+    });
+  }
+
+  /**
+   * Get execution plan
+   */
+  getExecutionPlan() {
+    const plan = {
+      phases: [],
+      summary: {
+        totalStrategies: this.strategies.length,
+        criticalStrategies: this.strategies.filter(s => s.priority === PRIORITY_LEVELS.CRITICAL).length,
+        highStrategies: this.strategies.filter(s => s.priority === PRIORITY_LEVELS.HIGH).length,
+        totalEffort: this.strategies.reduce((sum, s) => sum + s.estimatedEffort, 0)
+      }
+    };
+
+    // Group strategies by priority into phases
+    const phases = [
+      { name: 'Critical Refactoring', priority: PRIORITY_LEVELS.CRITICAL, strategies: [] },
+      { name: 'High Priority Refactoring', priority: PRIORITY_LEVELS.HIGH, strategies: [] },
+      { name: 'Medium Priority Refactoring', priority: PRIORITY_LEVELS.MEDIUM, strategies: [] },
+      { name: 'Low Priority Optimizations', priority: PRIORITY_LEVELS.LOW, strategies: [] }
+    ];
+
+    for (const strategy of this.strategies) {
+      const phase = phases.find(p => p.priority === strategy.priority);
+      if (phase) {
+        phase.strategies.push(strategy);
+      }
+    }
+
+    plan.phases = phases.filter(phase => phase.strategies.length > 0);
+    return plan;
+  }
+}
+
+module.exports = {
+  StrategyGenerator,
+  RefactoringStrategy,
+  STRATEGY_TYPES,
+  PRIORITY_LEVELS
+};