vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/refactoring/refactoring-executor.js

@@ -12,220 +12,15 @@ 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
-    };
-  }
-}
+const { EXECUTION_STATUS } = require('./execution-status');
+const { RefactoringOperation } = require('./refactoring-operation');
+const { RefactoringPlan } = require('./refactoring-plan');
+const { RefactoringExecutorResult } = require('./refactoring-executor-result');
+const { ExecutionStrategies } = require('./execution-strategies');
+const { PlanValidator } = require('./plan-validator');
+const { OperationExecutor } = require('./operation-executor');
+const { PlanExecutor } = require('./plan-executor');
+const { PlanCreator } = require('./plan-creator');
 
 /**
  * Refactoring executor class
@@ -249,8 +44,24 @@ class RefactoringExecutor {
     this.codeMover = new CodeMover();
     this.circularDependencyResolver = new CircularDependencyResolver();
     
-    this.currentPlan = null;
-    this.isExecuting = false;
+    this.executionStrategies = new ExecutionStrategies({
+      fileSplitter: this.fileSplitter,
+      boundaryExtractor: this.boundaryExtractor,
+      codeMover: this.codeMover,
+      importManager: this.importManager,
+      circularDependencyResolver: this.circularDependencyResolver
+    });
+    
+    this.planValidator = new PlanValidator();
+    this.operationExecutor = new OperationExecutor(this.executionStrategies);
+    this.planExecutor = new PlanExecutor(
+      this.operationExecutor,
+      this.testRunner,
+      this.rollbackManager,
+      this.options
+    );
+    this.planCreator = new PlanCreator();
+    
     this.executionQueue = [];
   }
 
@@ -258,395 +69,49 @@ class RefactoringExecutor {
    * 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;
+    return this.planExecutor.executePlan(plan);
   }
 
   /**
    * 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;
-          }
-        }
-      }));
-    }
+    return this.operationExecutor.executeOperations(plan, result, this.options);
   }
 
   /**
    * 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
-    };
+    return this.operationExecutor.executeOperation(operation, result);
   }
 
   /**
    * 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;
+    return this.planCreator.createPlan(analysisResults, options);
   }
 
   /**
    * 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;
+    return this.planExecutor.cancelExecution();
   }
 
   /**
    * 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
-      }
-    };
+    return this.planExecutor.getExecutionStatus();
   }
 
   /**
    * 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
-    };
+    return this.planValidator.validatePlan(plan);
   }
 
   /**