vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/refactoring/refactoring-rollback.js

@@ -0,0 +1,614 @@
+/**
+ * Refactoring Rollback
+ * 
+ * Provides rollback capabilities for failed refactoring operations.
+ * 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
+    };
+  }
+}
+
+/**
+ * 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;
+  }
+
+  /**
+   * 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;
+    }
+  }
+
+  /**
+   * 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}`);
+    }
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * 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()
+      }))
+    };
+  }
+
+  /**
+   * 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 };
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * 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)}`;
+  }
+
+  /**
+   * Check if rollback is available for an operation
+   */
+  hasRollbackPoint(operationId) {
+    const rollbackOps = this.rollbackHistory.get(operationId);
+    return rollbackOps && rollbackOps.length > 0;
+  }
+
+  /**
+   * Get rollback operations for an operation
+   */
+  getRollbackOperations(operationId) {
+    return this.rollbackHistory.get(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;
+  }
+
+  /**
+   * 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');
+  }
+}
+
+module.exports = {
+  RefactoringRollback,
+  RollbackOperation,
+  RollbackResult,
+  ROLLBACK_STATUS
+};