vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/refactoring/refactoring-rollback.js

@@ -5,604 +5,99 @@
  * Ensures safe restoration of original state with comprehensive tracking.
  */
 
-const fs = require('fs');
-const path = require('path');
-const { RollbackManager } = require('../utils/rollback-manager');
-
-/**
- * Rollback status
- */
-const ROLLBACK_STATUS = {
-  PENDING: 'pending',
-  RUNNING: 'running',
-  COMPLETED: 'completed',
-  FAILED: 'failed',
-  PARTIAL: 'partial'
-};
-
-/**
- * Rollback operation class
- */
-class RollbackOperation {
-  constructor(operationId, type, targetPath) {
-    this.id = this.generateId();
-    this.operationId = operationId;
-    this.type = type;
-    this.targetPath = targetPath;
-    this.status = ROLLBACK_STATUS.PENDING;
-    this.startTime = null;
-    this.endTime = null;
-    this.duration = 0;
-    this.success = false;
-    this.errors = [];
-    this.warnings = [];
-    this.metadata = {
-      createdAt: new Date().toISOString(),
-      backupPath: null,
-      originalSize: 0,
-      restoredSize: 0
-    };
-  }
-
-  generateId() {
-    return `rollback_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  setStatus(status) {
-    this.status = status;
-    if (status === ROLLBACK_STATUS.RUNNING && !this.startTime) {
-      this.startTime = new Date().toISOString();
-    }
-    if ([ROLLBACK_STATUS.COMPLETED, ROLLBACK_STATUS.FAILED, ROLLBACK_STATUS.PARTIAL].includes(status)) {
-      this.endTime = new Date().toISOString();
-      this.duration = this.endTime && this.startTime ? 
-        (new Date(this.endTime) - new Date(this.startTime)) / 1000 : 0;
-    }
-  }
-
-  setSuccess(success) {
-    this.success = success;
-  }
-
-  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()
-    });
-  }
-
-  setBackupPath(backupPath) {
-    this.metadata.backupPath = backupPath;
-  }
-
-  setOriginalSize(size) {
-    this.metadata.originalSize = size;
-  }
-
-  setRestoredSize(size) {
-    this.metadata.restoredSize = size;
-  }
-
-  getSummary() {
-    return {
-      id: this.id,
-      operationId: this.operationId,
-      type: this.type,
-      targetPath: this.targetPath,
-      status: this.status,
-      success: this.success,
-      duration: this.duration,
-      errorCount: this.errors.length,
-      warningCount: this.warnings.length,
-      backupPath: this.metadata.backupPath
-    };
-  }
-}
-
-/**
- * Rollback result class
- */
-class RollbackResult {
-  constructor(rollbackId) {
-    this.rollbackId = rollbackId;
-    this.operations = [];
-    this.status = ROLLBACK_STATUS.PENDING;
-    this.success = false;
-    this.startTime = null;
-    this.endTime = null;
-    this.duration = 0;
-    this.errors = [];
-    this.warnings = [];
-    this.metadata = {
-      createdAt: new Date().toISOString(),
-      triggerReason: '',
-      affectedFiles: 0,
-      totalFilesRestored: 0
-    };
-  }
-
-  addOperation(operation) {
-    this.operations.push(operation);
-  }
-
-  setStatus(status) {
-    this.status = status;
-    if (status === ROLLBACK_STATUS.RUNNING && !this.startTime) {
-      this.startTime = new Date().toISOString();
-    }
-    if ([ROLLBACK_STATUS.COMPLETED, ROLLBACK_STATUS.FAILED, ROLLBACK_STATUS.PARTIAL].includes(status)) {
-      this.endTime = new Date().toISOString();
-      this.duration = this.endTime && this.startTime ? 
-        (new Date(this.endTime) - new Date(this.startTime)) / 1000 : 0;
-    }
-  }
-
-  setSuccess(success) {
-    this.success = success;
-  }
-
-  setTriggerReason(reason) {
-    this.metadata.triggerReason = reason;
-  }
-
-  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()
-    });
-  }
-
-  calculateSummary() {
-    const successfulOps = this.operations.filter(op => op.success).length;
-    const failedOps = this.operations.filter(op => !op.success).length;
-    
-    if (failedOps === 0) {
-      this.setStatus(ROLLBACK_STATUS.COMPLETED);
-      this.setSuccess(true);
-    } else if (successfulOps > 0) {
-      this.setStatus(ROLLBACK_STATUS.PARTIAL);
-      this.setSuccess(false);
-    } else {
-      this.setStatus(ROLLBACK_STATUS.FAILED);
-      this.setSuccess(false);
-    }
-    
-    this.metadata.affectedFiles = this.operations.length;
-    this.metadata.totalFilesRestored = successfulOps;
-  }
-
-  getSummary() {
-    this.calculateSummary();
-    
-    return {
-      rollbackId: this.rollbackId,
-      status: this.status,
-      success: this.success,
-      duration: this.duration,
-      triggerReason: this.metadata.triggerReason,
-      affectedFiles: this.metadata.affectedFiles,
-      totalFilesRestored: this.metadata.totalFilesRestored,
-      operations: this.operations.map(op => op.getSummary()),
-      errorCount: this.errors.length,
-      warningCount: this.warnings.length
-    };
-  }
-}
+const { RollbackOperation, ROLLBACK_STATUS } = require('./rollback-handlers/RollbackOperation');
+const { RollbackResult } = require('./rollback-handlers/RollbackResult');
+const { RollbackManager } = require('./rollback-handlers/RollbackManager');
+const { RollbackStatistics } = require('./rollback-handlers/RollbackStatistics');
 
 /**
  * Refactoring rollback manager class
  */
 class RefactoringRollback {
   constructor(options = {}) {
-    this.options = {
-      createBackups: true,
-      validateAfterRollback: true,
-      preserveRollbackLogs: true,
-      maxRollbackAttempts: 3,
-      ...options
-    };
-    
-    this.rollbackManager = new RollbackManager();
-    this.rollbackHistory = new Map();
-    this.currentRollback = null;
-    this.isRollingBack = false;
+    this.manager = new RollbackManager(options);
+    this.statistics = new RollbackStatistics(this.manager.rollbackHistory);
   }
 
   /**
    * Create rollback point for a refactoring operation
    */
   async createRollbackPoint(operationId, operation) {
-    console.log(`Creating rollback point for operation: ${operationId}`);
-    
-    try {
-      const rollbackOp = new RollbackOperation(operationId, 'create_backup', operation.targetPath);
-      
-      // Create backup for each affected file
-      for (const affectedFile of operation.affectedFiles || [operation.targetPath]) {
-        if (fs.existsSync(affectedFile)) {
-          const backupPath = this.rollbackManager.backupFile(affectedFile);
-          rollbackOp.setBackupPath(backupPath);
-          rollbackOp.setOriginalSize(fs.statSync(affectedFile).size);
-        }
-      }
-      
-      rollbackOp.setStatus(ROLLBACK_STATUS.COMPLETED);
-      rollbackOp.setSuccess(true);
-      
-      // Store rollback operation
-      if (!this.rollbackHistory.has(operationId)) {
-        this.rollbackHistory.set(operationId, []);
-      }
-      this.rollbackHistory.get(operationId).push(rollbackOp);
-      
-      console.log(`Rollback point created for ${operationId}`);
-      
-      return rollbackOp;
-      
-    } catch (error) {
-      console.error(`Failed to create rollback point for ${operationId}:`, error.message);
-      throw error;
-    }
+    return this.manager.createRollbackPoint(operationId, operation);
   }
 
   /**
    * Execute rollback for a failed operation
    */
   async executeRollback(operationId, reason = 'Operation failed') {
-    if (this.isRollingBack) {
-      throw new Error('Rollback already in progress');
-    }
-    
-    this.isRollingBack = true;
-    const rollbackId = this.generateRollbackId();
-    const result = new RollbackResult(rollbackId);
-    result.setTriggerReason(reason);
-    
-    try {
-      console.log(`Executing rollback for operation: ${operationId}`);
-      result.setStatus(ROLLBACK_STATUS.RUNNING);
-      
-      // Get rollback operations for the operation
-      const rollbackOps = this.rollbackHistory.get(operationId) || [];
-      
-      if (rollbackOps.length === 0) {
-        throw new Error(`No rollback point found for operation: ${operationId}`);
-      }
-      
-      // Execute rollback operations in reverse order
-      const reversedOps = rollbackOps.reverse();
-      
-      for (const rollbackOp of reversedOps) {
-        try {
-          await this.executeRollbackOperation(rollbackOp);
-          result.addOperation(rollbackOp);
-        } catch (error) {
-          rollbackOp.addError(error);
-          rollbackOp.setStatus(ROLLBACK_STATUS.FAILED);
-          rollbackOp.setSuccess(false);
-          result.addOperation(rollbackOp);
-          
-          // Continue with other operations even if one fails
-          console.warn(`Rollback operation failed: ${rollbackOp.id}`, error.message);
-        }
-      }
-      
-      // Validate rollback if enabled
-      if (this.options.validateAfterRollback) {
-        await this.validateRollback(result);
-      }
-      
-      result.calculateSummary();
-      
-      console.log(`Rollback completed: ${result.success ? 'SUCCESS' : 'PARTIAL/FAILED'}`);
-      
-    } catch (error) {
-      result.addError(error);
-      result.setStatus(ROLLBACK_STATUS.FAILED);
-      result.setSuccess(false);
-      console.error(`Rollback execution failed:`, error.message);
-    } finally {
-      this.isRollingBack = false;
-      this.currentRollback = result;
-    }
-    
-    return result;
-  }
-
-  /**
-   * Execute individual rollback operation
-   */
-  async executeRollbackOperation(rollbackOp) {
-    console.log(`Executing rollback operation: ${rollbackOp.id}`);
-    rollbackOp.setStatus(ROLLBACK_STATUS.RUNNING);
-    
-    try {
-      if (!rollbackOp.metadata.backupPath || !fs.existsSync(rollbackOp.metadata.backupPath)) {
-        throw new Error(`Backup file not found: ${rollbackOp.metadata.backupPath}`);
-      }
-      
-      // Restore file from backup
-      const targetDir = path.dirname(rollbackOp.targetPath);
-      if (!fs.existsSync(targetDir)) {
-        fs.mkdirSync(targetDir, { recursive: true });
-      }
-      
-      fs.copyFileSync(rollbackOp.metadata.backupPath, rollbackOp.targetPath);
-      
-      // Verify restoration
-      if (fs.existsSync(rollbackOp.targetPath)) {
-        const restoredSize = fs.statSync(rollbackOp.targetPath).size;
-        rollbackOp.setRestoredSize(restoredSize);
-        
-        // Check if size matches (basic integrity check)
-        if (Math.abs(restoredSize - rollbackOp.metadata.originalSize) > 100) {
-          rollbackOp.addWarning('File size difference detected after restoration');
-        }
-      } else {
-        throw new Error('Failed to restore file');
-      }
-      
-      rollbackOp.setStatus(ROLLBACK_STATUS.COMPLETED);
-      rollbackOp.setSuccess(true);
-      
-      console.log(`Rollback operation completed: ${rollbackOp.id}`);
-      
-    } catch (error) {
-      rollbackOp.addError(error);
-      rollbackOp.setStatus(ROLLBACK_STATUS.FAILED);
-      rollbackOp.setSuccess(false);
-      throw error;
-    }
-  }
-
-  /**
-   * Validate rollback results
-   */
-  async validateRollback(result) {
-    console.log('Validating rollback results...');
-    
-    for (const operation of result.operations) {
-      if (operation.success) {
-        try {
-          // Basic file existence check
-          if (!fs.existsSync(operation.targetPath)) {
-            operation.addWarning('Target file does not exist after rollback');
-          }
-          
-          // Basic syntax check for JavaScript files
-          if (operation.targetPath.endsWith('.js') && fs.existsSync(operation.targetPath)) {
-            const content = fs.readFileSync(operation.targetPath, 'utf8');
-            this.validateJavaScriptSyntax(content);
-          }
-          
-        } catch (error) {
-          operation.addError(error);
-        }
-      }
-    }
-  }
-
-  /**
-   * Validate JavaScript syntax
-   */
-  validateJavaScriptSyntax(content) {
-    try {
-      const vm = require('vm');
-      new vm.Script(content, { filename: 'validation' });
-    } catch (error) {
-      throw new Error(`JavaScript syntax validation failed: ${error.message}`);
-    }
+    return this.manager.executeRollback(operationId, reason);
   }
 
   /**
    * Cancel current rollback
    */
   async cancelRollback() {
-    if (!this.isRollingBack || !this.currentRollback) {
-      return false;
-    }
-    
-    this.currentRollback.setStatus(ROLLBACK_STATUS.FAILED);
-    this.currentRollback.addError(new Error('Rollback cancelled by user'));
-    this.isRollingBack = false;
-    
-    return true;
+    return this.manager.cancelRollback();
   }
 
   /**
    * Get rollback status
    */
   getRollbackStatus() {
-    return {
-      isRollingBack: this.isRollingBack,
-      currentRollback: this.currentRollback ? this.currentRollback.getSummary() : null,
-      rollbackHistory: Array.from(this.rollbackHistory.entries()).map(([opId, ops]) => ({
-        operationId: opId,
-        rollbackOperations: ops.length,
-        lastRollback: ops[ops.length - 1]?.getSummary()
-      }))
-    };
+    return this.manager.getRollbackStatus();
   }
 
   /**
    * Clean up old rollback points
    */
-  async cleanup(maxAge = 7 * 24 * 60 * 60 * 1000) { // 7 days default
-    console.log('Cleaning up old rollback points...');
-    
-    let cleaned = 0;
-    const now = Date.now();
-    
-    for (const [operationId, rollbackOps] of this.rollbackHistory.entries()) {
-      const recentOps = rollbackOps.filter(op => {
-        const createdAt = new Date(op.metadata.createdAt).getTime();
-        return (now - createdAt) < maxAge;
-      });
-      
-      if (recentOps.length < rollbackOps.length) {
-        this.rollbackHistory.set(operationId, recentOps);
-        cleaned += rollbackOps.length - recentOps.length;
-      }
-    }
-    
-    // Clean up rollback manager backups
-    const backupCleaned = this.rollbackManager.cleanup(maxAge);
-    
-    console.log(`Cleanup completed: ${cleaned} rollback operations, ${backupCleaned} backup files`);
-    
-    return { rollbackOperations: cleaned, backupFiles: backupCleaned };
+  async cleanup(maxAge = 7 * 24 * 60 * 60 * 1000) {
+    return this.manager.cleanup(maxAge);
   }
 
   /**
    * Get rollback statistics
    */
   getStatistics() {
-    const stats = {
-      totalRollbackPoints: 0,
-      totalRollbacks: 0,
-      successfulRollbacks: 0,
-      failedRollbacks: 0,
-      partialRollbacks: 0,
-      averageRollbackTime: 0,
-      commonFailureReasons: {},
-      oldestRollback: null,
-      newestRollback: null
-    };
-    
-    let totalTime = 0;
-    let oldestTime = null;
-    let newestTime = null;
-    const failureReasons = {};
-    
-    for (const rollbackOps of this.rollbackHistory.values()) {
-      stats.totalRollbackPoints += rollbackOps.length;
-      
-      for (const op of rollbackOps) {
-        if (op.endTime) {
-          const opTime = new Date(op.endTime);
-          if (!oldestTime || opTime < oldestTime) oldestTime = opTime;
-          if (!newestTime || opTime > newestTime) newestTime = opTime;
-        }
-      }
-    }
-    
-    stats.oldestRollback = oldestTime ? oldestTime.toISOString() : null;
-    stats.newestRollback = newestTime ? newestTime.toISOString() : null;
-    
-    return stats;
+    return this.statistics.getStatistics();
   }
 
   /**
    * Export rollback data
    */
   exportRollbackData(format = 'json') {
-    const exportData = {
-      metadata: {
-        exportedAt: new Date().toISOString(),
-        version: '1.0.0',
-        options: this.options
-      },
-      rollbackHistory: Array.from(this.rollbackHistory.entries()).map(([opId, ops]) => ({
-        operationId: opId,
-        operations: ops.map(op => op.getSummary())
-      })),
-      currentRollback: this.currentRollback ? this.currentRollback.getSummary() : null,
-      statistics: this.getStatistics()
-    };
-    
-    if (format === 'json') {
-      return JSON.stringify(exportData, null, 2);
-    }
-    
-    return exportData;
-  }
-
-  /**
-   * Generate rollback ID
-   */
-  generateRollbackId() {
-    return `rollback_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    return this.statistics.exportRollbackData(
+      this.manager.options,
+      this.manager.currentRollback,
+      format
+    );
   }
 
   /**
    * Check if rollback is available for an operation
    */
   hasRollbackPoint(operationId) {
-    const rollbackOps = this.rollbackHistory.get(operationId);
-    return rollbackOps && rollbackOps.length > 0;
+    return this.manager.hasRollbackPoint(operationId);
   }
 
   /**
    * Get rollback operations for an operation
    */
   getRollbackOperations(operationId) {
-    return this.rollbackHistory.get(operationId) || [];
+    return this.manager.getRollbackOperations(operationId);
   }
 
   /**
    * Remove rollback point for an operation
    */
   removeRollbackPoint(operationId) {
-    const rollbackOps = this.rollbackHistory.get(operationId);
-    if (rollbackOps) {
-      // Clean up backup files
-      for (const op of rollbackOps) {
-        if (op.metadata.backupPath && fs.existsSync(op.metadata.backupPath)) {
-          try {
-            fs.unlinkSync(op.metadata.backupPath);
-          } catch (error) {
-            console.warn(`Failed to cleanup backup file: ${op.metadata.backupPath}`, error.message);
-          }
-        }
-      }
-      
-      this.rollbackHistory.delete(operationId);
-      return true;
-    }
-    
-    return false;
+    return this.manager.removeRollbackPoint(operationId);
   }
 
   /**
    * Reset all rollback data
    */
   reset() {
-    console.log('Resetting all rollback data...');
-    
-    // Clean up all backup files
-    for (const rollbackOps of this.rollbackHistory.values()) {
-      for (const op of rollbackOps) {
-        if (op.metadata.backupPath && fs.existsSync(op.metadata.backupPath)) {
-          try {
-            fs.unlinkSync(op.metadata.backupPath);
-          } catch (error) {
-            console.warn(`Failed to cleanup backup file: ${op.metadata.backupPath}`, error.message);
-          }
-        }
-      }
-    }
-    
-    this.rollbackHistory.clear();
-    this.currentRollback = null;
-    this.isRollingBack = false;
-    
-    console.log('Rollback data reset completed');
+    return this.manager.reset();
   }
 }