vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/refactoring/refactoring-executor.js

@@ -0,0 +1,672 @@
+/**
+ * Refactoring Executor
+ * 
+ * Orchestrates the entire refactoring process.
+ * Coordinates multiple refactoring operations and ensures consistency.
+ */
+
+const { FileSplitter } = require('./file-splitter');
+const { BoundaryExtractor } = require('./boundary-extractor');
+const { CodeMover } = require('./code-mover');
+const { ImportManager } = require('./import-manager');
+const { CircularDependencyResolver } = require('./circular-dependency-resolver');
+const { RollbackManager } = require('../utils/rollback-manager');
+const { TestRunner } = require('../utils/test-runner');
+
+/**
+ * Execution status
+ */
+const EXECUTION_STATUS = {
+  PENDING: 'pending',
+  RUNNING: 'running',
+  COMPLETED: 'completed',
+  FAILED: 'failed',
+  PAUSED: 'paused',
+  CANCELLED: 'cancelled'
+};
+
+/**
+ * Refactoring operation class
+ */
+class RefactoringOperation {
+  constructor(type, targetPath, options = {}) {
+    this.id = this.generateId();
+    this.type = type;
+    this.targetPath = targetPath;
+    this.options = options;
+    this.status = EXECUTION_STATUS.PENDING;
+    this.progress = 0;
+    this.result = null;
+    this.error = null;
+    this.startTime = null;
+    this.endTime = null;
+    this.dependencies = [];
+    this.dependents = [];
+    this.metadata = {
+      createdAt: new Date().toISOString(),
+      estimatedDuration: options.estimatedDuration || 0,
+      priority: options.priority || 'medium'
+    };
+  }
+
+  generateId() {
+    return `op_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  setStatus(status) {
+    this.status = status;
+    if (status === EXECUTION_STATUS.RUNNING && !this.startTime) {
+      this.startTime = new Date().toISOString();
+    }
+    if ([EXECUTION_STATUS.COMPLETED, EXECUTION_STATUS.FAILED, EXECUTION_STATUS.CANCELLED].includes(status)) {
+      this.endTime = new Date().toISOString();
+    }
+  }
+
+  setProgress(progress) {
+    this.progress = Math.max(0, Math.min(100, progress));
+  }
+
+  setResult(result) {
+    this.result = result;
+  }
+
+  setError(error) {
+    this.error = error;
+  }
+
+  addDependency(operationId) {
+    if (!this.dependencies.includes(operationId)) {
+      this.dependencies.push(operationId);
+    }
+  }
+
+  addDependent(operationId) {
+    if (!this.dependents.includes(operationId)) {
+      this.dependents.push(operationId);
+    }
+  }
+
+  getDuration() {
+    if (!this.startTime) return 0;
+    const end = this.endTime ? new Date(this.endTime) : new Date();
+    const start = new Date(this.startTime);
+    return (end - start) / 1000; // seconds
+  }
+
+  isReady(dependencies) {
+    if (this.status !== EXECUTION_STATUS.PENDING) return false;
+    
+    for (const depId of this.dependencies) {
+      const dep = dependencies.get(depId);
+      if (!dep || dep.status !== EXECUTION_STATUS.COMPLETED) {
+        return false;
+      }
+    }
+    
+    return true;
+  }
+}
+
+/**
+ * Refactoring execution plan class
+ */
+class RefactoringPlan {
+  constructor(name) {
+    this.id = this.generateId();
+    this.name = name;
+    this.operations = new Map();
+    this.status = EXECUTION_STATUS.PENDING;
+    this.metadata = {
+      createdAt: new Date().toISOString(),
+      estimatedDuration: 0,
+      totalOperations: 0
+    };
+  }
+
+  generateId() {
+    return `plan_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  addOperation(operation) {
+    this.operations.set(operation.id, operation);
+    this.metadata.totalOperations = this.operations.size;
+    this.updateEstimatedDuration();
+  }
+
+  updateEstimatedDuration() {
+    this.metadata.estimatedDuration = Array.from(this.operations.values())
+      .reduce((total, op) => total + (op.metadata.estimatedDuration || 0), 0);
+  }
+
+  getReadyOperations() {
+    return Array.from(this.operations.values())
+      .filter(op => op.isReady(this.operations));
+  }
+
+  getCompletedOperations() {
+    return Array.from(this.operations.values())
+      .filter(op => op.status === EXECUTION_STATUS.COMPLETED);
+  }
+
+  getFailedOperations() {
+    return Array.from(this.operations.values())
+      .filter(op => op.status === EXECUTION_STATUS.FAILED);
+  }
+
+  getProgress() {
+    if (this.operations.size === 0) return 0;
+    
+    const completed = this.getCompletedOperations().length;
+    return Math.round((completed / this.operations.size) * 100);
+  }
+
+  setStatus(status) {
+    this.status = status;
+  }
+}
+
+/**
+ * Refactoring executor result class
+ */
+class RefactoringExecutorResult {
+  constructor(plan) {
+    this.plan = plan;
+    this.success = false;
+    this.executedOperations = 0;
+    this.failedOperations = 0;
+    this.skippedOperations = 0;
+    this.duration = 0;
+    this.errors = [];
+    this.warnings = [];
+    this.rollbackPerformed = false;
+    this.metadata = {
+      executedAt: new Date().toISOString(),
+      environment: process.env.NODE_ENV || 'development'
+    };
+  }
+
+  addError(error) {
+    this.errors.push({
+      message: error.message,
+      timestamp: new Date().toISOString(),
+      stack: error.stack
+    });
+  }
+
+  addWarning(warning) {
+    this.warnings.push({
+      message: warning,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  setSuccess(success) {
+    this.success = success;
+  }
+
+  setRollbackPerformed(rollbackPerformed) {
+    this.rollbackPerformed = rollbackPerformed;
+  }
+
+  getSummary() {
+    return {
+      planId: this.plan.id,
+      planName: this.plan.name,
+      success: this.success,
+      executedOperations: this.executedOperations,
+      failedOperations: this.failedOperations,
+      skippedOperations: this.skippedOperations,
+      totalOperations: this.plan.operations.size,
+      duration: this.duration,
+      progress: this.plan.getProgress(),
+      errorCount: this.errors.length,
+      warningCount: this.warnings.length,
+      rollbackPerformed: this.rollbackPerformed
+    };
+  }
+}
+
+/**
+ * Refactoring executor class
+ */
+class RefactoringExecutor {
+  constructor(options = {}) {
+    this.options = {
+      maxConcurrentOperations: 3,
+      enableRollback: true,
+      runTests: true,
+      validateAfterOperation: true,
+      pauseOnError: true,
+      ...options
+    };
+    
+    this.rollbackManager = new RollbackManager();
+    this.testRunner = new TestRunner();
+    this.importManager = new ImportManager();
+    this.fileSplitter = new FileSplitter();
+    this.boundaryExtractor = new BoundaryExtractor();
+    this.codeMover = new CodeMover();
+    this.circularDependencyResolver = new CircularDependencyResolver();
+    
+    this.currentPlan = null;
+    this.isExecuting = false;
+    this.executionQueue = [];
+  }
+
+  /**
+   * Execute a refactoring plan
+   */
+  async executePlan(plan) {
+    if (this.isExecuting) {
+      throw new Error('Executor is already running a plan');
+    }
+    
+    this.currentPlan = plan;
+    this.isExecuting = true;
+    plan.setStatus(EXECUTION_STATUS.RUNNING);
+    
+    const result = new RefactoringExecutorResult(plan);
+    const startTime = Date.now();
+    
+    try {
+      console.log(`Executing refactoring plan: ${plan.name}`);
+      console.log(`Operations: ${plan.operations.size}`);
+      
+      // Run baseline tests if enabled
+      if (this.options.runTests) {
+        console.log('Running baseline tests...');
+        await this.testRunner.runBaseline();
+      }
+      
+      // Execute operations in dependency order
+      await this.executeOperations(plan, result);
+      
+      // Run validation tests if enabled
+      if (this.options.runTests) {
+        console.log('Running validation tests...');
+        const testResult = await this.testRunner.runValidation();
+        
+        if (testResult.hasRegressions) {
+          throw new Error('Tests detected regressions after refactoring');
+        }
+      }
+      
+      result.setSuccess(true);
+      plan.setStatus(EXECUTION_STATUS.COMPLETED);
+      
+      console.log(`Plan execution completed successfully`);
+      
+    } catch (error) {
+      result.addError(error);
+      result.setSuccess(false);
+      plan.setStatus(EXECUTION_STATUS.FAILED);
+      
+      console.error(`Plan execution failed: ${error.message}`);
+      
+      // Rollback if enabled and there were failures
+      if (this.options.enableRollback && result.failedOperations > 0) {
+        console.log('Performing rollback...');
+        await this.rollbackManager.rollback();
+        result.setRollbackPerformed(true);
+      }
+      
+      if (this.options.pauseOnError) {
+        console.log('Execution paused due to error');
+        plan.setStatus(EXECUTION_STATUS.PAUSED);
+      }
+      
+    } finally {
+      result.duration = (Date.now() - startTime) / 1000;
+      this.isExecuting = false;
+      this.currentPlan = null;
+    }
+    
+    return result;
+  }
+
+  /**
+   * Execute operations in dependency order
+   */
+  async executeOperations(plan, result) {
+    const executedOperations = new Set();
+    let pendingOperations = new Set(plan.operations.keys());
+    
+    while (pendingOperations.size > 0) {
+      // Find ready operations
+      const readyOperations = Array.from(pendingOperations)
+        .map(id => plan.operations.get(id))
+        .filter(op => op.isReady(plan.operations) && !executedOperations.has(op.id));
+      
+      if (readyOperations.length === 0) {
+        // Check for circular dependencies or blocked operations
+        const blockedOps = Array.from(pendingOperations)
+          .map(id => plan.operations.get(id))
+          .filter(op => !executedOperations.has(op.id));
+        
+        if (blockedOps.length > 0) {
+          throw new Error(`Circular dependency detected or operations blocked: ${blockedOps.map(op => op.id).join(', ')}`);
+        }
+        break;
+      }
+      
+      // Execute ready operations (with concurrency limit)
+      const batchSize = Math.min(readyOperations.length, this.options.maxConcurrentOperations);
+      const batch = readyOperations.slice(0, batchSize);
+      
+      await Promise.all(batch.map(async operation => {
+        try {
+          await this.executeOperation(operation, result);
+          executedOperations.add(operation.id);
+          pendingOperations.delete(operation.id);
+          result.executedOperations++;
+        } catch (error) {
+          result.addError(error);
+          result.failedOperations++;
+          executedOperations.add(operation.id);
+          pendingOperations.delete(operation.id);
+          
+          // Don't continue on error if pauseOnError is enabled
+          if (this.options.pauseOnError) {
+            throw error;
+          }
+        }
+      }));
+    }
+  }
+
+  /**
+   * Execute a single operation
+   */
+  async executeOperation(operation, result) {
+    console.log(`Executing operation: ${operation.type} on ${operation.targetPath}`);
+    operation.setStatus(EXECUTION_STATUS.RUNNING);
+    operation.setProgress(0);
+    
+    try {
+      let operationResult = null;
+      
+      switch (operation.type) {
+        case 'split_file':
+          operationResult = await this.executeSplitFile(operation);
+          break;
+          
+        case 'extract_boundaries':
+          operationResult = await this.executeExtractBoundaries(operation);
+          break;
+          
+        case 'move_code':
+          operationResult = await this.executeMoveCode(operation);
+          break;
+          
+        case 'update_imports':
+          operationResult = await this.executeUpdateImports(operation);
+          break;
+          
+        case 'resolve_circular_deps':
+          operationResult = await this.executeResolveCircularDeps(operation);
+          break;
+          
+        default:
+          throw new Error(`Unknown operation type: ${operation.type}`);
+      }
+      
+      operation.setResult(operationResult);
+      operation.setStatus(EXECUTION_STATUS.COMPLETED);
+      operation.setProgress(100);
+      
+      console.log(`Operation completed: ${operation.id}`);
+      
+    } catch (error) {
+      operation.setError(error);
+      operation.setStatus(EXECUTION_STATUS.FAILED);
+      throw error;
+    }
+  }
+
+  /**
+   * Execute file split operation
+   */
+  async executeSplitFile(operation) {
+    const { targetPath, splitPoints } = operation.options;
+    
+    // Read file analysis (would come from operation context)
+    const fileAnalysis = await this.analyzeFile(targetPath);
+    
+    const splitResult = await this.fileSplitter.splitFile(fileAnalysis, splitPoints);
+    
+    if (!splitResult.success) {
+      throw new Error(`File split failed: ${splitResult.errors.map(e => e.message).join(', ')}`);
+    }
+    
+    return splitResult;
+  }
+
+  /**
+   * Execute boundary extraction operation
+   */
+  async executeExtractBoundaries(operation) {
+    const { targetPath, boundaries } = operation.options;
+    
+    const extractionResult = await this.boundaryExtractor.extractBoundaries(targetPath);
+    
+    if (extractionResult.errors.length > 0) {
+      throw new Error(`Boundary extraction failed: ${extractionResult.errors.map(e => e.message).join(', ')}`);
+    }
+    
+    return extractionResult;
+  }
+
+  /**
+   * Execute code move operation
+   */
+  async executeMoveCode(operation) {
+    const { sourcePath, targetPath, segment } = operation.options;
+    
+    const moveOperation = {
+      type: 'extract',
+      sourcePath,
+      targetPath,
+      segmentName: segment.name,
+      startLine: segment.startLine,
+      endLine: segment.endLine
+    };
+    
+    const moveResult = await this.codeMover.executeMove(moveOperation);
+    
+    if (!moveResult.success) {
+      throw new Error(`Code move failed: ${moveResult.errors.map(e => e.message).join(', ')}`);
+    }
+    
+    return moveResult;
+  }
+
+  /**
+   * Execute import update operation
+   */
+  async executeUpdateImports(operation) {
+    const { targetPath, changes } = operation.options;
+    
+    const updateResult = await this.importManager.updateImports(targetPath, changes);
+    
+    if (!updateResult.success) {
+      throw new Error(`Import update failed: ${updateResult.errors.map(e => e.message).join(', ')}`);
+    }
+    
+    return updateResult;
+  }
+
+  /**
+   * Execute circular dependency resolution
+   */
+  async executeResolveCircularDeps(operation) {
+    const { rootPath, strategies } = operation.options;
+    
+    const analysisResult = await this.circularDependencyResolver.analyze(rootPath);
+    
+    if (analysisResult.errors.length > 0) {
+      throw new Error(`Circular dependency analysis failed: ${analysisResult.errors.map(e => e.message).join(', ')}`);
+    }
+    
+    return analysisResult;
+  }
+
+  /**
+   * Analyze file for refactoring
+   */
+  async analyzeFile(filePath) {
+    // This would create a FileAnalysis object
+    // For now, return a placeholder
+    return {
+      filePath,
+      lineCount: 100,
+      needsRefactoring: true,
+      boundaries: null
+    };
+  }
+
+  /**
+   * Create refactoring plan from analysis results
+   */
+  createPlan(analysisResults, options = {}) {
+    const plan = new RefactoringResults(options.name || 'Auto-generated Plan');
+    
+    // Create operations based on analysis
+    for (const analysis of analysisResults.files || []) {
+      if (analysis.needsRefactoring) {
+        // Add split operation
+        const splitOp = new RefactoringOperation('split_file', analysis.filePath, {
+          estimatedDuration: 5,
+          priority: analysis.urgentRefactoring ? 'high' : 'medium'
+        });
+        plan.addOperation(splitOp);
+      }
+    }
+    
+    return plan;
+  }
+
+  /**
+   * Cancel current execution
+   */
+  async cancelExecution() {
+    if (!this.isExecuting || !this.currentPlan) {
+      return false;
+    }
+    
+    this.currentPlan.setStatus(EXECUTION_STATUS.CANCELLED);
+    this.isExecuting = false;
+    
+    // Cancel running operations
+    for (const operation of this.currentPlan.operations.values()) {
+      if (operation.status === EXECUTION_STATUS.RUNNING) {
+        operation.setStatus(EXECUTION_STATUS.CANCELLED);
+      }
+    }
+    
+    return true;
+  }
+
+  /**
+   * Get execution status
+   */
+  getExecutionStatus() {
+    if (!this.currentPlan) {
+      return {
+        isExecuting: false,
+        plan: null,
+        progress: 0
+      };
+    }
+    
+    return {
+      isExecuting: this.isExecuting,
+      plan: {
+        id: this.currentPlan.id,
+        name: this.currentPlan.name,
+        status: this.currentPlan.status,
+        progress: this.currentPlan.getProgress(),
+        totalOperations: this.currentPlan.operations.size,
+        completedOperations: this.currentPlan.getCompletedOperations().length,
+        failedOperations: this.currentPlan.getFailedOperations().length
+      }
+    };
+  }
+
+  /**
+   * Validate plan before execution
+   */
+  validatePlan(plan) {
+    const issues = [];
+    
+    // Check for circular dependencies
+    const visited = new Set();
+    const recursionStack = new Set();
+    
+    function hasCircularDeps(operationId) {
+      if (recursionStack.has(operationId)) {
+        return true;
+      }
+      
+      if (visited.has(operationId)) {
+        return false;
+      }
+      
+      visited.add(operationId);
+      recursionStack.add(operationId);
+      
+      const operation = plan.operations.get(operationId);
+      if (operation) {
+        for (const depId of operation.dependencies) {
+          if (hasCircularDeps(depId)) {
+            return true;
+          }
+        }
+      }
+      
+      recursionStack.delete(operationId);
+      return false;
+    }
+    
+    for (const operationId of plan.operations.keys()) {
+      if (hasCircularDeps(operationId)) {
+        issues.push(`Circular dependency detected for operation: ${operationId}`);
+      }
+    }
+    
+    // Check for missing dependencies
+    for (const operation of plan.operations.values()) {
+      for (const depId of operation.dependencies) {
+        if (!plan.operations.has(depId)) {
+          issues.push(`Missing dependency: ${depId} for operation: ${operation.id}`);
+        }
+      }
+    }
+    
+    return {
+      isValid: issues.length === 0,
+      issues
+    };
+  }
+
+  /**
+   * Get execution statistics
+   */
+  getStatistics() {
+    return {
+      totalPlansExecuted: 0, // Would track this
+      averageExecutionTime: 0,
+      successRate: 0,
+      mostCommonOperations: {},
+      errorPatterns: []
+    };
+  }
+}
+
+module.exports = {
+  RefactoringExecutor,
+  RefactoringPlan,
+  RefactoringOperation,
+  RefactoringExecutorResult,
+  EXECUTION_STATUS
+};