aios-core 4.1.0 → 4.2.0

package/.aios-core/development/scripts/rollback-handler.js

@@ -1,531 +1,531 @@
-/**
- * Rollback Handler for AIOS-FULLSTACK
- * Handles undo operations for component transactions
- * @module rollback-handler
- */
-
-const TransactionManager = require('./transaction-manager');
-const chalk = require('chalk');
-const inquirer = require('inquirer');
-const path = require('path');
-const fs = require('fs').promises;
-const ModificationValidator = require('./modification-validator');
-
-class RollbackHandler {
-  constructor(options = {}) {
-    this.rootPath = options.rootPath || process.cwd();
-    this.transactionManager = new TransactionManager({ rootPath: this.rootPath });
-    this.modificationValidator = new ModificationValidator();
-    this.backupPath = path.join(this.rootPath, 'aios-core', '.backups');
-  }
-
-  /**
-   * Execute undo-last command
-   * @param {Object} options - Rollback options
-   * @returns {Promise<Object>} Rollback result
-   */
-  async undoLast(options = {}) {
-    try {
-      let transaction;
-      
-      if (options.transactionId) {
-        // Load specific transaction
-        transaction = await this.transactionManager.loadTransaction(options.transactionId);
-        if (!transaction) {
-          throw new Error(`Transaction not found: ${options.transactionId}`);
-        }
-      } else {
-        // Get last transaction
-        transaction = await this.transactionManager.getLastTransaction();
-        if (!transaction) {
-          console.log(chalk.yellow('No transactions found to rollback'));
-          return { success: false, error: 'No transactions found' };
-        }
-      }
-      
-      // Display transaction details
-      console.log(chalk.blue('\n📋 Transaction Details:'));
-      console.log(chalk.gray(`ID: ${transaction.id}`));
-      console.log(chalk.gray(`Type: ${transaction.type}`));
-      console.log(chalk.gray(`Date: ${new Date(transaction.startTime).toLocaleString()}`));
-      console.log(chalk.gray(`Status: ${transaction.status}`));
-      console.log(chalk.gray(`Operations: ${transaction.operations.length}`));
-      
-      // Show operations
-      console.log(chalk.blue('\n📝 Operations to rollback:'));
-      for (const op of transaction.operations) {
-        const icon = this.getOperationIcon(op.type);
-        console.log(chalk.gray(`  ${icon} ${op.type}: ${path.basename(op.path)}`));
-      }
-      
-      // Confirm rollback
-      if (!options.force) {
-        const { confirm } = await inquirer.prompt([{
-          type: 'confirm',
-          name: 'confirm',
-          message: 'Do you want to rollback this transaction?',
-          default: true
-        }]);
-        
-        if (!confirm) {
-          console.log(chalk.yellow('Rollback cancelled'));
-          return { success: false, error: 'User cancelled' };
-        }
-      }
-      
-      // Execute rollback
-      console.log(chalk.blue('\n⚙️  Executing rollback...'));
-      
-      const rollbackResult = await this.transactionManager.rollbackTransaction(
-        transaction.id,
-        {
-          continueOnError: options.continueOnError !== false
-        }
-      );
-      
-      // Display results
-      this.displayRollbackResults(rollbackResult);
-      
-      return {
-        success: rollbackResult.failed.length === 0,
-        result: rollbackResult
-      };
-      
-    } catch (error) {
-      console.error(chalk.red(`\n❌ Rollback failed: ${error.message}`));
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * List recent transactions
-   * @param {number} limit - Number of transactions to show
-   * @returns {Promise<void>}
-   */
-  async listTransactions(limit = 10) {
-    try {
-      const transactions = await this.transactionManager.listTransactions(limit);
-      
-      if (transactions.length === 0) {
-        console.log(chalk.yellow('No transactions found'));
-        return;
-      }
-      
-      console.log(chalk.blue('\n📋 Recent Transactions:'));
-      console.log(chalk.gray('─'.repeat(80)));
-      
-      for (const txn of transactions) {
-        const date = new Date(txn.startTime).toLocaleString();
-        const duration = txn.endTime 
-          ? `${new Date(txn.endTime) - new Date(txn.startTime)}ms`
-          : 'active';
-        
-        console.log(chalk.white(`\nID: ${txn.id}`));
-        console.log(chalk.gray(`Type: ${txn.type}`));
-        console.log(chalk.gray(`Description: ${txn.description}`));
-        console.log(chalk.gray(`User: ${txn.user}`));
-        console.log(chalk.gray(`Date: ${date}`));
-        console.log(chalk.gray(`Status: ${this.getStatusColor(txn.status)}`));
-        console.log(chalk.gray(`Operations: ${txn.operations}`));
-        console.log(chalk.gray(`Duration: ${duration}`));
-        console.log(chalk.gray('─'.repeat(80)));
-      }
-      
-    } catch (error) {
-      console.error(chalk.red(`Failed to list transactions: ${error.message}`));
-    }
-  }
-
-  /**
-   * Execute selective rollback
-   * @param {string} transactionId - Transaction ID
-   * @param {Array<string>} operationIds - Specific operations to rollback
-   * @returns {Promise<Object>} Rollback result
-   */
-  async selectiveRollback(transactionId, operationIds) {
-    try {
-      const transaction = await this.transactionManager.loadTransaction(transactionId);
-      if (!transaction) {
-        throw new Error(`Transaction not found: ${transactionId}`);
-      }
-      
-      // Filter operations
-      const selectedOps = transaction.operations.filter(op => 
-        operationIds.includes(op.id)
-      );
-      
-      if (selectedOps.length === 0) {
-        throw new Error('No matching operations found');
-      }
-      
-      console.log(chalk.blue(`\n📝 Selective rollback: ${selectedOps.length} operations`));
-      
-      // Create a new transaction for selective rollback
-      const rollbackTxnId = await this.transactionManager.beginTransaction({
-        type: 'selective_rollback',
-        description: `Selective rollback of ${transactionId}`,
-        metadata: {
-          originalTransaction: transactionId,
-          selectedOperations: operationIds
-        }
-      });
-      
-      const results = {
-        successful: [],
-        failed: [],
-        warnings: []
-      };
-      
-      // Rollback selected operations
-      for (const op of selectedOps) {
-        try {
-          await this.transactionManager.rollbackOperation(op, results);
-        } catch (error) {
-          results.failed.push({
-            operation: op.id,
-            error: error.message
-          });
-        }
-      }
-      
-      // Commit rollback transaction
-      await this.transactionManager.commitTransaction(rollbackTxnId);
-      
-      this.displayRollbackResults(results);
-      
-      return {
-        success: results.failed.length === 0,
-        result: results
-      };
-      
-    } catch (error) {
-      console.error(chalk.red(`Selective rollback failed: ${error.message}`));
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * Clean up old transactions
-   * @returns {Promise<number>} Number cleaned
-   */
-  async cleanup() {
-    try {
-      console.log(chalk.blue('🧹 Cleaning up old transactions...'));
-      const cleaned = await this.transactionManager.cleanupOldTransactions();
-      console.log(chalk.green(`✅ Cleaned up ${cleaned} old transactions`));
-      return cleaned;
-    } catch (error) {
-      console.error(chalk.red(`Cleanup failed: ${error.message}`));
-      return 0;
-    }
-  }
-
-  /**
-   * Create backup before modification
-   * @param {string} componentType - Type of component
-   * @param {string} componentName - Name of component
-   * @param {string} content - Content to backup
-   * @returns {Promise<string>} Backup file path
-   */
-  async createBackup(componentType, componentName, content) {
-    try {
-      // Ensure backup directory exists
-      await fs.mkdir(this.backupPath, { recursive: true });
-      
-      // Create subdirectory for component type
-      const typeBackupPath = path.join(this.backupPath, componentType);
-      await fs.mkdir(typeBackupPath, { recursive: true });
-      
-      // Generate backup filename with timestamp
-      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-      const backupFilename = `${componentName}.${timestamp}.backup`;
-      const backupFilePath = path.join(typeBackupPath, backupFilename);
-      
-      // Write backup
-      await fs.writeFile(backupFilePath, content, 'utf8');
-      
-      // Record backup in transaction
-      if (this.currentTransactionId) {
-        await this.transactionManager.recordOperation({
-          type: 'backup_created',
-          path: backupFilePath,
-          componentType,
-          componentName,
-          timestamp
-        });
-      }
-      
-      return backupFilePath;
-    } catch (error) {
-      throw new Error(`Failed to create backup: ${error.message}`);
-    }
-  }
-
-  /**
-   * Restore from backup
-   * @param {string} backupPath - Path to backup file
-   * @param {string} targetPath - Path to restore to
-   * @returns {Promise<boolean>} Success status
-   */
-  async restoreFromBackup(backupPath, targetPath) {
-    try {
-      // Verify backup exists
-      await fs.access(backupPath);
-      
-      // Read backup content
-      const content = await fs.readFile(backupPath, 'utf8');
-      
-      // Restore to target
-      await fs.writeFile(targetPath, content, 'utf8');
-      
-      console.log(chalk.green(`✅ Restored from backup: ${path.basename(backupPath)}`));
-      return true;
-    } catch (error) {
-      console.error(chalk.red(`Failed to restore from backup: ${error.message}`));
-      return false;
-    }
-  }
-
-  /**
-   * Validate modification before applying
-   * @param {string} componentType - Type of component
-   * @param {string} originalContent - Original content
-   * @param {string} modifiedContent - Modified content
-   * @returns {Promise<Object>} Validation result
-   */
-  async validateModification(componentType, originalContent, modifiedContent) {
-    const validation = await this.modificationValidator.validateModification(
-      componentType,
-      originalContent,
-      modifiedContent
-    );
-    
-    if (!validation.valid) {
-      console.log(chalk.red('\n❌ Modification validation failed:'));
-      validation.errors.forEach(error => {
-        console.log(chalk.red(`   • ${error}`));
-      });
-    }
-    
-    if (validation.warnings.length > 0) {
-      console.log(chalk.yellow('\n⚠️  Warnings:'));
-      validation.warnings.forEach(warning => {
-        console.log(chalk.yellow(`   • ${warning}`));
-      });
-    }
-    
-    if (validation.breakingChanges.length > 0) {
-      console.log(chalk.red('\n🚨 Breaking Changes Detected:'));
-      validation.breakingChanges.forEach(change => {
-        console.log(chalk.red(`   • ${change.type}: ${change.impact}`));
-        if (change.items) {
-          console.log(chalk.red(`     Items: ${change.items.join(', ')}`));
-        }
-      });
-    }
-    
-    return validation;
-  }
-
-  /**
-   * Rollback modification
-   * @param {Object} modificationData - Modification details
-   * @returns {Promise<Object>} Rollback result
-   */
-  async rollbackModification(modificationData) {
-    const { componentType, componentName, backupPath, targetPath } = modificationData;
-    
-    try {
-      console.log(chalk.blue(`\n⏪ Rolling back ${componentType}: ${componentName}`));
-      
-      // Restore from backup
-      const restored = await this.restoreFromBackup(backupPath, targetPath);
-      
-      if (restored) {
-        // Record rollback
-        await this.transactionManager.recordOperation({
-          type: 'modification_rollback',
-          componentType,
-          componentName,
-          backupPath,
-          targetPath,
-          timestamp: new Date().toISOString()
-        });
-        
-        return {
-          success: true,
-          message: `Successfully rolled back ${componentType}: ${componentName}`
-        };
-      } else {
-        throw new Error('Restoration failed');
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * List available backups for a component
-   * @param {string} componentType - Type of component
-   * @param {string} componentName - Name of component
-   * @returns {Promise<Array>} List of backups
-   */
-  async listBackups(componentType, componentName) {
-    try {
-      const typeBackupPath = path.join(this.backupPath, componentType);
-      const files = await fs.readdir(typeBackupPath);
-      
-      const backups = files
-        .filter(file => file.startsWith(`${componentName}.`) && file.endsWith('.backup'))
-        .map(file => {
-          const match = file.match(/\.(\d{4}-\d{2}-\d{2}T[\d-]+Z)\.backup$/);
-          const timestamp = match ? match[1].replace(/-/g, ':') : 'unknown';
-          
-          return {
-            filename: file,
-            path: path.join(typeBackupPath, file),
-            timestamp: new Date(timestamp),
-            componentName,
-            componentType
-          };
-        })
-        .sort((a, b) => b.timestamp - a.timestamp);
-      
-      return backups;
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        return [];
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Clean up old backups
-   * @param {number} daysToKeep - Number of days to keep backups
-   * @returns {Promise<number>} Number of backups deleted
-   */
-  async cleanupBackups(daysToKeep = 30) {
-    try {
-      const cutoffDate = new Date();
-      cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
-      
-      let deletedCount = 0;
-      
-      // Iterate through component types
-      const componentTypes = await fs.readdir(this.backupPath);
-      
-      for (const componentType of componentTypes) {
-        const typePath = path.join(this.backupPath, componentType);
-        const stat = await fs.stat(typePath);
-        
-        if (!stat.isDirectory()) continue;
-        
-        const files = await fs.readdir(typePath);
-        
-        for (const file of files) {
-          if (!file.endsWith('.backup')) continue;
-          
-          const filePath = path.join(typePath, file);
-          const fileStat = await fs.stat(filePath);
-          
-          if (fileStat.mtime < cutoffDate) {
-            await fs.unlink(filePath);
-            deletedCount++;
-          }
-        }
-      }
-      
-      return deletedCount;
-    } catch (error) {
-      console.error(chalk.red(`Backup cleanup failed: ${error.message}`));
-      return 0;
-    }
-  }
-
-  /**
-   * Get operation icon
-   * @private
-   */
-  getOperationIcon(type) {
-    const icons = {
-      create: '➕',
-      update: '✏️',
-      delete: '🗑️',
-      manifest_update: '📋',
-      metadata_update: '📊',
-      component_created: '📦',
-      backup_created: '💾',
-      modification_rollback: '⏪'
-    };
-    
-    return icons[type] || '•';
-  }
-
-  /**
-   * Get status color
-   * @private
-   */
-  getStatusColor(status) {
-    switch (status) {
-      case 'active':
-        return chalk.yellow(status);
-      case 'committed':
-        return chalk.green(status);
-      case 'rolled_back':
-        return chalk.blue(status);
-      case 'failed':
-        return chalk.red(status);
-      default:
-        return status;
-    }
-  }
-
-  /**
-   * Display rollback results
-   * @private
-   */
-  displayRollbackResults(results) {
-    console.log(chalk.blue('\n📊 Rollback Results:'));
-    
-    if (results.successful.length > 0) {
-      console.log(chalk.green(`\n✅ Successful (${results.successful.length}):`));
-      results.successful.forEach(item => {
-        console.log(chalk.green(`   ✓ ${item.action}: ${path.basename(item.path)}`));
-      });
-    }
-    
-    if (results.warnings.length > 0) {
-      console.log(chalk.yellow(`\n⚠️  Warnings (${results.warnings.length}):`));
-      results.warnings.forEach(item => {
-        console.log(chalk.yellow(`   ⚠ ${item.warning}: ${path.basename(item.path || 'N/A')}`));
-      });
-    }
-    
-    if (results.failed.length > 0) {
-      console.log(chalk.red(`\n❌ Failed (${results.failed.length}):`));
-      results.failed.forEach(item => {
-        console.log(chalk.red(`   ✗ ${item.operation}: ${item.error}`));
-      });
-    }
-    
-    // Summary
-    const total = results.successful.length + results.failed.length;
-    const successRate = total > 0 ? (results.successful.length / total * 100).toFixed(0) : 0;
-    
-    console.log(chalk.blue('\n📈 Summary:'));
-    console.log(chalk.gray(`   Total operations: ${total}`));
-    console.log(chalk.gray(`   Success rate: ${successRate}%`));
-  }
-}
-
+/**
+ * Rollback Handler for AIOS-FULLSTACK
+ * Handles undo operations for component transactions
+ * @module rollback-handler
+ */
+
+const TransactionManager = require('./transaction-manager');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const path = require('path');
+const fs = require('fs').promises;
+const ModificationValidator = require('./modification-validator');
+
+class RollbackHandler {
+  constructor(options = {}) {
+    this.rootPath = options.rootPath || process.cwd();
+    this.transactionManager = new TransactionManager({ rootPath: this.rootPath });
+    this.modificationValidator = new ModificationValidator();
+    this.backupPath = path.join(this.rootPath, 'aios-core', '.backups');
+  }
+
+  /**
+   * Execute undo-last command
+   * @param {Object} options - Rollback options
+   * @returns {Promise<Object>} Rollback result
+   */
+  async undoLast(options = {}) {
+    try {
+      let transaction;
+      
+      if (options.transactionId) {
+        // Load specific transaction
+        transaction = await this.transactionManager.loadTransaction(options.transactionId);
+        if (!transaction) {
+          throw new Error(`Transaction not found: ${options.transactionId}`);
+        }
+      } else {
+        // Get last transaction
+        transaction = await this.transactionManager.getLastTransaction();
+        if (!transaction) {
+          console.log(chalk.yellow('No transactions found to rollback'));
+          return { success: false, error: 'No transactions found' };
+        }
+      }
+      
+      // Display transaction details
+      console.log(chalk.blue('\n📋 Transaction Details:'));
+      console.log(chalk.gray(`ID: ${transaction.id}`));
+      console.log(chalk.gray(`Type: ${transaction.type}`));
+      console.log(chalk.gray(`Date: ${new Date(transaction.startTime).toLocaleString()}`));
+      console.log(chalk.gray(`Status: ${transaction.status}`));
+      console.log(chalk.gray(`Operations: ${transaction.operations.length}`));
+      
+      // Show operations
+      console.log(chalk.blue('\n📝 Operations to rollback:'));
+      for (const op of transaction.operations) {
+        const icon = this.getOperationIcon(op.type);
+        console.log(chalk.gray(`  ${icon} ${op.type}: ${path.basename(op.path)}`));
+      }
+      
+      // Confirm rollback
+      if (!options.force) {
+        const { confirm } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'confirm',
+          message: 'Do you want to rollback this transaction?',
+          default: true
+        }]);
+        
+        if (!confirm) {
+          console.log(chalk.yellow('Rollback cancelled'));
+          return { success: false, error: 'User cancelled' };
+        }
+      }
+      
+      // Execute rollback
+      console.log(chalk.blue('\n⚙️  Executing rollback...'));
+      
+      const rollbackResult = await this.transactionManager.rollbackTransaction(
+        transaction.id,
+        {
+          continueOnError: options.continueOnError !== false
+        }
+      );
+      
+      // Display results
+      this.displayRollbackResults(rollbackResult);
+      
+      return {
+        success: rollbackResult.failed.length === 0,
+        result: rollbackResult
+      };
+      
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Rollback failed: ${error.message}`));
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * List recent transactions
+   * @param {number} limit - Number of transactions to show
+   * @returns {Promise<void>}
+   */
+  async listTransactions(limit = 10) {
+    try {
+      const transactions = await this.transactionManager.listTransactions(limit);
+      
+      if (transactions.length === 0) {
+        console.log(chalk.yellow('No transactions found'));
+        return;
+      }
+      
+      console.log(chalk.blue('\n📋 Recent Transactions:'));
+      console.log(chalk.gray('─'.repeat(80)));
+      
+      for (const txn of transactions) {
+        const date = new Date(txn.startTime).toLocaleString();
+        const duration = txn.endTime 
+          ? `${new Date(txn.endTime) - new Date(txn.startTime)}ms`
+          : 'active';
+        
+        console.log(chalk.white(`\nID: ${txn.id}`));
+        console.log(chalk.gray(`Type: ${txn.type}`));
+        console.log(chalk.gray(`Description: ${txn.description}`));
+        console.log(chalk.gray(`User: ${txn.user}`));
+        console.log(chalk.gray(`Date: ${date}`));
+        console.log(chalk.gray(`Status: ${this.getStatusColor(txn.status)}`));
+        console.log(chalk.gray(`Operations: ${txn.operations}`));
+        console.log(chalk.gray(`Duration: ${duration}`));
+        console.log(chalk.gray('─'.repeat(80)));
+      }
+      
+    } catch (error) {
+      console.error(chalk.red(`Failed to list transactions: ${error.message}`));
+    }
+  }
+
+  /**
+   * Execute selective rollback
+   * @param {string} transactionId - Transaction ID
+   * @param {Array<string>} operationIds - Specific operations to rollback
+   * @returns {Promise<Object>} Rollback result
+   */
+  async selectiveRollback(transactionId, operationIds) {
+    try {
+      const transaction = await this.transactionManager.loadTransaction(transactionId);
+      if (!transaction) {
+        throw new Error(`Transaction not found: ${transactionId}`);
+      }
+      
+      // Filter operations
+      const selectedOps = transaction.operations.filter(op => 
+        operationIds.includes(op.id)
+      );
+      
+      if (selectedOps.length === 0) {
+        throw new Error('No matching operations found');
+      }
+      
+      console.log(chalk.blue(`\n📝 Selective rollback: ${selectedOps.length} operations`));
+      
+      // Create a new transaction for selective rollback
+      const rollbackTxnId = await this.transactionManager.beginTransaction({
+        type: 'selective_rollback',
+        description: `Selective rollback of ${transactionId}`,
+        metadata: {
+          originalTransaction: transactionId,
+          selectedOperations: operationIds
+        }
+      });
+      
+      const results = {
+        successful: [],
+        failed: [],
+        warnings: []
+      };
+      
+      // Rollback selected operations
+      for (const op of selectedOps) {
+        try {
+          await this.transactionManager.rollbackOperation(op, results);
+        } catch (error) {
+          results.failed.push({
+            operation: op.id,
+            error: error.message
+          });
+        }
+      }
+      
+      // Commit rollback transaction
+      await this.transactionManager.commitTransaction(rollbackTxnId);
+      
+      this.displayRollbackResults(results);
+      
+      return {
+        success: results.failed.length === 0,
+        result: results
+      };
+      
+    } catch (error) {
+      console.error(chalk.red(`Selective rollback failed: ${error.message}`));
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Clean up old transactions
+   * @returns {Promise<number>} Number cleaned
+   */
+  async cleanup() {
+    try {
+      console.log(chalk.blue('🧹 Cleaning up old transactions...'));
+      const cleaned = await this.transactionManager.cleanupOldTransactions();
+      console.log(chalk.green(`✅ Cleaned up ${cleaned} old transactions`));
+      return cleaned;
+    } catch (error) {
+      console.error(chalk.red(`Cleanup failed: ${error.message}`));
+      return 0;
+    }
+  }
+
+  /**
+   * Create backup before modification
+   * @param {string} componentType - Type of component
+   * @param {string} componentName - Name of component
+   * @param {string} content - Content to backup
+   * @returns {Promise<string>} Backup file path
+   */
+  async createBackup(componentType, componentName, content) {
+    try {
+      // Ensure backup directory exists
+      await fs.mkdir(this.backupPath, { recursive: true });
+      
+      // Create subdirectory for component type
+      const typeBackupPath = path.join(this.backupPath, componentType);
+      await fs.mkdir(typeBackupPath, { recursive: true });
+      
+      // Generate backup filename with timestamp
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupFilename = `${componentName}.${timestamp}.backup`;
+      const backupFilePath = path.join(typeBackupPath, backupFilename);
+      
+      // Write backup
+      await fs.writeFile(backupFilePath, content, 'utf8');
+      
+      // Record backup in transaction
+      if (this.currentTransactionId) {
+        await this.transactionManager.recordOperation({
+          type: 'backup_created',
+          path: backupFilePath,
+          componentType,
+          componentName,
+          timestamp
+        });
+      }
+      
+      return backupFilePath;
+    } catch (error) {
+      throw new Error(`Failed to create backup: ${error.message}`);
+    }
+  }
+
+  /**
+   * Restore from backup
+   * @param {string} backupPath - Path to backup file
+   * @param {string} targetPath - Path to restore to
+   * @returns {Promise<boolean>} Success status
+   */
+  async restoreFromBackup(backupPath, targetPath) {
+    try {
+      // Verify backup exists
+      await fs.access(backupPath);
+      
+      // Read backup content
+      const content = await fs.readFile(backupPath, 'utf8');
+      
+      // Restore to target
+      await fs.writeFile(targetPath, content, 'utf8');
+      
+      console.log(chalk.green(`✅ Restored from backup: ${path.basename(backupPath)}`));
+      return true;
+    } catch (error) {
+      console.error(chalk.red(`Failed to restore from backup: ${error.message}`));
+      return false;
+    }
+  }
+
+  /**
+   * Validate modification before applying
+   * @param {string} componentType - Type of component
+   * @param {string} originalContent - Original content
+   * @param {string} modifiedContent - Modified content
+   * @returns {Promise<Object>} Validation result
+   */
+  async validateModification(componentType, originalContent, modifiedContent) {
+    const validation = await this.modificationValidator.validateModification(
+      componentType,
+      originalContent,
+      modifiedContent
+    );
+    
+    if (!validation.valid) {
+      console.log(chalk.red('\n❌ Modification validation failed:'));
+      validation.errors.forEach(error => {
+        console.log(chalk.red(`   • ${error}`));
+      });
+    }
+    
+    if (validation.warnings.length > 0) {
+      console.log(chalk.yellow('\n⚠️  Warnings:'));
+      validation.warnings.forEach(warning => {
+        console.log(chalk.yellow(`   • ${warning}`));
+      });
+    }
+    
+    if (validation.breakingChanges.length > 0) {
+      console.log(chalk.red('\n🚨 Breaking Changes Detected:'));
+      validation.breakingChanges.forEach(change => {
+        console.log(chalk.red(`   • ${change.type}: ${change.impact}`));
+        if (change.items) {
+          console.log(chalk.red(`     Items: ${change.items.join(', ')}`));
+        }
+      });
+    }
+    
+    return validation;
+  }
+
+  /**
+   * Rollback modification
+   * @param {Object} modificationData - Modification details
+   * @returns {Promise<Object>} Rollback result
+   */
+  async rollbackModification(modificationData) {
+    const { componentType, componentName, backupPath, targetPath } = modificationData;
+    
+    try {
+      console.log(chalk.blue(`\n⏪ Rolling back ${componentType}: ${componentName}`));
+      
+      // Restore from backup
+      const restored = await this.restoreFromBackup(backupPath, targetPath);
+      
+      if (restored) {
+        // Record rollback
+        await this.transactionManager.recordOperation({
+          type: 'modification_rollback',
+          componentType,
+          componentName,
+          backupPath,
+          targetPath,
+          timestamp: new Date().toISOString()
+        });
+        
+        return {
+          success: true,
+          message: `Successfully rolled back ${componentType}: ${componentName}`
+        };
+      } else {
+        throw new Error('Restoration failed');
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * List available backups for a component
+   * @param {string} componentType - Type of component
+   * @param {string} componentName - Name of component
+   * @returns {Promise<Array>} List of backups
+   */
+  async listBackups(componentType, componentName) {
+    try {
+      const typeBackupPath = path.join(this.backupPath, componentType);
+      const files = await fs.readdir(typeBackupPath);
+      
+      const backups = files
+        .filter(file => file.startsWith(`${componentName}.`) && file.endsWith('.backup'))
+        .map(file => {
+          const match = file.match(/\.(\d{4}-\d{2}-\d{2}T[\d-]+Z)\.backup$/);
+          const timestamp = match ? match[1].replace(/-/g, ':') : 'unknown';
+          
+          return {
+            filename: file,
+            path: path.join(typeBackupPath, file),
+            timestamp: new Date(timestamp),
+            componentName,
+            componentType
+          };
+        })
+        .sort((a, b) => b.timestamp - a.timestamp);
+      
+      return backups;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return [];
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Clean up old backups
+   * @param {number} daysToKeep - Number of days to keep backups
+   * @returns {Promise<number>} Number of backups deleted
+   */
+  async cleanupBackups(daysToKeep = 30) {
+    try {
+      const cutoffDate = new Date();
+      cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
+      
+      let deletedCount = 0;
+      
+      // Iterate through component types
+      const componentTypes = await fs.readdir(this.backupPath);
+      
+      for (const componentType of componentTypes) {
+        const typePath = path.join(this.backupPath, componentType);
+        const stat = await fs.stat(typePath);
+        
+        if (!stat.isDirectory()) continue;
+        
+        const files = await fs.readdir(typePath);
+        
+        for (const file of files) {
+          if (!file.endsWith('.backup')) continue;
+          
+          const filePath = path.join(typePath, file);
+          const fileStat = await fs.stat(filePath);
+          
+          if (fileStat.mtime < cutoffDate) {
+            await fs.unlink(filePath);
+            deletedCount++;
+          }
+        }
+      }
+      
+      return deletedCount;
+    } catch (error) {
+      console.error(chalk.red(`Backup cleanup failed: ${error.message}`));
+      return 0;
+    }
+  }
+
+  /**
+   * Get operation icon
+   * @private
+   */
+  getOperationIcon(type) {
+    const icons = {
+      create: '➕',
+      update: '✏️',
+      delete: '🗑️',
+      manifest_update: '📋',
+      metadata_update: '📊',
+      component_created: '📦',
+      backup_created: '💾',
+      modification_rollback: '⏪'
+    };
+    
+    return icons[type] || '•';
+  }
+
+  /**
+   * Get status color
+   * @private
+   */
+  getStatusColor(status) {
+    switch (status) {
+      case 'active':
+        return chalk.yellow(status);
+      case 'committed':
+        return chalk.green(status);
+      case 'rolled_back':
+        return chalk.blue(status);
+      case 'failed':
+        return chalk.red(status);
+      default:
+        return status;
+    }
+  }
+
+  /**
+   * Display rollback results
+   * @private
+   */
+  displayRollbackResults(results) {
+    console.log(chalk.blue('\n📊 Rollback Results:'));
+    
+    if (results.successful.length > 0) {
+      console.log(chalk.green(`\n✅ Successful (${results.successful.length}):`));
+      results.successful.forEach(item => {
+        console.log(chalk.green(`   ✓ ${item.action}: ${path.basename(item.path)}`));
+      });
+    }
+    
+    if (results.warnings.length > 0) {
+      console.log(chalk.yellow(`\n⚠️  Warnings (${results.warnings.length}):`));
+      results.warnings.forEach(item => {
+        console.log(chalk.yellow(`   ⚠ ${item.warning}: ${path.basename(item.path || 'N/A')}`));
+      });
+    }
+    
+    if (results.failed.length > 0) {
+      console.log(chalk.red(`\n❌ Failed (${results.failed.length}):`));
+      results.failed.forEach(item => {
+        console.log(chalk.red(`   ✗ ${item.operation}: ${item.error}`));
+      });
+    }
+    
+    // Summary
+    const total = results.successful.length + results.failed.length;
+    const successRate = total > 0 ? (results.successful.length / total * 100).toFixed(0) : 0;
+    
+    console.log(chalk.blue('\n📈 Summary:'));
+    console.log(chalk.gray(`   Total operations: ${total}`));
+    console.log(chalk.gray(`   Success rate: ${successRate}%`));
+  }
+}
+
 module.exports = RollbackHandler;