claude-flow 2.0.0-alpha.60 → 2.0.0-alpha.62

package/src/migration/rollback-manager.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * Rollback Manager - Handles rollback operations and backup management
  */
@@ -36,8 +35,8 @@ export class RollbackManager {
       metadata: {
         projectPath: this.projectPath,
         backupId,
-        ...metadata
-      }
+        ...metadata,
+      },
     };
 
     // Backup critical files and directories
@@ -47,7 +46,7 @@ export class RollbackManager {
       '.roomodes',
       'package.json',
       'memory/memory-store.json',
-      'coordination/config.json'
+      'coordination/config.json',
     ];
 
     for (const target of backupTargets) {
@@ -76,11 +75,15 @@ export class RollbackManager {
     return backup;
   }
 
-  private async backupDirectory(sourcePath: string, targetPath: string, backup: MigrationBackup): Promise<void> {
+  private async backupDirectory(
+    sourcePath: string,
+    targetPath: string,
+    backup: MigrationBackup,
+  ): Promise<void> {
     await fs.ensureDir(targetPath);
-    
+
     const entries = await fs.readdir(sourcePath);
-    
+
     for (const entry of entries) {
       const entrySource = path.join(sourcePath, entry);
       const entryTarget = path.join(targetPath, entry);
@@ -95,10 +98,15 @@ export class RollbackManager {
     }
   }
 
-  private async backupFile(sourcePath: string, targetPath: string, backup: MigrationBackup, relativePath: string): Promise<void> {
+  private async backupFile(
+    sourcePath: string,
+    targetPath: string,
+    backup: MigrationBackup,
+    relativePath: string,
+  ): Promise<void> {
     const content = await fs.readFile(sourcePath, 'utf-8');
     const checksum = crypto.createHash('sha256').update(content).digest('hex');
-    
+
     await fs.ensureDir(path.dirname(targetPath));
     await fs.writeFile(targetPath, content);
 
@@ -106,14 +114,14 @@ export class RollbackManager {
       path: relativePath,
       content,
       checksum,
-      permissions: (await fs.stat(sourcePath)).mode.toString(8)
+      permissions: (await fs.stat(sourcePath)).mode.toString(8),
     };
 
     backup.files.push(backupFile);
   }
 
   async listBackups(): Promise<MigrationBackup[]> {
-    if (!await fs.pathExists(this.backupDir)) {
+    if (!(await fs.pathExists(this.backupDir))) {
       return [];
     }
 
@@ -122,13 +130,15 @@ export class RollbackManager {
 
     for (const folder of backupFolders.sort().reverse()) {
       const manifestPath = path.join(this.backupDir, folder, 'backup-manifest.json');
-      
+
       if (await fs.pathExists(manifestPath)) {
         try {
           const backup = await fs.readJson(manifestPath);
           backups.push(backup);
         } catch (error) {
-          logger.warn(`Invalid backup manifest in ${folder}: ${(error instanceof Error ? error.message : String(error))}`);
+          logger.warn(
+            `Invalid backup manifest in ${folder}: ${error instanceof Error ? error.message : String(error)}`,
+          );
         }
       }
     }
@@ -138,7 +148,7 @@ export class RollbackManager {
 
   async rollback(backupId?: string, interactive: boolean = true): Promise<void> {
     const backups = await this.listBackups();
-    
+
     if (backups.length === 0) {
       throw new Error('No backups found');
     }
@@ -146,7 +156,7 @@ export class RollbackManager {
     let selectedBackup: MigrationBackup;
 
     if (backupId) {
-      selectedBackup = backups.find(b => b.metadata.backupId === backupId);
+      selectedBackup = backups.find((b) => b.metadata.backupId === backupId);
       if (!selectedBackup) {
         throw new Error(`Backup not found: ${backupId}`);
       }
@@ -160,12 +170,14 @@ export class RollbackManager {
 
     // Confirm rollback
     if (interactive) {
-      const confirm = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'proceed',
-        message: `Are you sure you want to rollback? This will overwrite current files.`,
-        default: false
-      }]);
+      const confirm = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'proceed',
+          message: `Are you sure you want to rollback? This will overwrite current files.`,
+          default: false,
+        },
+      ]);
 
       if (!confirm.proceed) {
         logger.info('Rollback cancelled');
@@ -176,21 +188,20 @@ export class RollbackManager {
     // Create pre-rollback backup
     const preRollbackBackup = await this.createBackup({
       type: 'pre-rollback',
-      rollingBackTo: selectedBackup.metadata.backupId
+      rollingBackTo: selectedBackup.metadata.backupId,
     });
 
     try {
       // Restore files
       await this.restoreFiles(selectedBackup);
-      
+
       // Validate restoration
       await this.validateRestore(selectedBackup);
-      
+
       logger.success('Rollback completed successfully');
-      
     } catch (error) {
       logger.error('Rollback failed, attempting to restore pre-rollback state...');
-      
+
       try {
         await this.restoreFiles(preRollbackBackup);
         logger.success('Pre-rollback state restored');
@@ -198,25 +209,27 @@ export class RollbackManager {
         logger.error('Failed to restore pre-rollback state:', restoreError);
         throw new Error('Rollback failed and unable to restore previous state');
       }
-      
+
       throw error;
     }
   }
 
   private async selectBackupInteractively(backups: MigrationBackup[]): Promise<MigrationBackup> {
-    const choices = backups.map(backup => ({
+    const choices = backups.map((backup) => ({
       name: `${backup.timestamp.toLocaleString()} - ${backup.files.length} files (${backup.metadata.type || 'migration'})`,
       value: backup,
-      short: backup.metadata.backupId
+      short: backup.metadata.backupId,
     }));
 
-    const answer = await inquirer.prompt([{
-      type: 'list',
-      name: 'backup',
-      message: 'Select backup to rollback to:',
-      choices,
-      pageSize: 10
-    }]);
+    const answer = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'backup',
+        message: 'Select backup to rollback to:',
+        choices,
+        pageSize: 10,
+      },
+    ]);
 
     return answer.backup;
   }
@@ -226,18 +239,20 @@ export class RollbackManager {
 
     for (const file of backup.files) {
       const targetPath = path.join(this.projectPath, file.path);
-      
+
       logger.debug(`Restoring ${file.path}`);
-      
+
       await fs.ensureDir(path.dirname(targetPath));
       await fs.writeFile(targetPath, file.content);
-      
+
       // Restore permissions if available
       if (file.permissions) {
         try {
           await fs.chmod(targetPath, parseInt(file.permissions, 8));
         } catch (error) {
-          logger.warn(`Could not restore permissions for ${file.path}: ${(error instanceof Error ? error.message : String(error))}`);
+          logger.warn(
+            `Could not restore permissions for ${file.path}: ${error instanceof Error ? error.message : String(error)}`,
+          );
         }
       }
     }
@@ -250,8 +265,8 @@ export class RollbackManager {
 
     for (const file of backup.files) {
       const filePath = path.join(this.projectPath, file.path);
-      
-      if (!await fs.pathExists(filePath)) {
+
+      if (!(await fs.pathExists(filePath))) {
         errors.push(`Missing file: ${file.path}`);
         continue;
       }
@@ -273,7 +288,7 @@ export class RollbackManager {
 
   async cleanupOldBackups(retentionDays: number = 30, maxBackups: number = 10): Promise<void> {
     const backups = await this.listBackups();
-    
+
     if (backups.length <= maxBackups) {
       return; // No cleanup needed
     }
@@ -281,16 +296,15 @@ export class RollbackManager {
     const cutoffDate = new Date();
     cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
 
-    const backupsToDelete = backups
-      .filter((backup, index) => {
-        // Keep the most recent maxBackups
-        if (index < maxBackups) {
-          return false;
-        }
-        
-        // Delete old backups
-        return backup.timestamp < cutoffDate;
-      });
+    const backupsToDelete = backups.filter((backup, index) => {
+      // Keep the most recent maxBackups
+      if (index < maxBackups) {
+        return false;
+      }
+
+      // Delete old backups
+      return backup.timestamp < cutoffDate;
+    });
 
     if (backupsToDelete.length === 0) {
       return;
@@ -309,7 +323,7 @@ export class RollbackManager {
 
   async getBackupInfo(backupId: string): Promise<MigrationBackup | null> {
     const backups = await this.listBackups();
-    return backups.find(b => b.metadata.backupId === backupId) || null;
+    return backups.find((b) => b.metadata.backupId === backupId) || null;
   }
 
   async exportBackup(backupId: string, exportPath: string): Promise<void> {
@@ -320,14 +334,14 @@ export class RollbackManager {
 
     const backupPath = path.join(this.backupDir, backup.metadata.backupId);
     await fs.copy(backupPath, exportPath);
-    
+
     logger.success(`Backup exported to ${exportPath}`);
   }
 
   async importBackup(importPath: string): Promise<MigrationBackup> {
     const manifestPath = path.join(importPath, 'backup-manifest.json');
-    
-    if (!await fs.pathExists(manifestPath)) {
+
+    if (!(await fs.pathExists(manifestPath))) {
       throw new Error('Invalid backup: missing manifest');
     }
 
@@ -343,7 +357,7 @@ export class RollbackManager {
 
   private async updateBackupIndex(backup: MigrationBackup): Promise<void> {
     const indexPath = path.join(this.backupDir, 'backup-index.json');
-    
+
     let index: Record<string, any> = {};
     if (await fs.pathExists(indexPath)) {
       index = await fs.readJson(indexPath);
@@ -353,7 +367,7 @@ export class RollbackManager {
       timestamp: backup.timestamp,
       version: backup.version,
       fileCount: backup.files.length,
-      metadata: backup.metadata
+      metadata: backup.metadata,
     };
 
     await fs.writeJson(indexPath, index, { spaces: 2 });
@@ -373,12 +387,14 @@ export class RollbackManager {
       const date = backup.timestamp.toLocaleString();
       const type = backup.metadata.type || 'migration';
       const fileCount = backup.files.length;
-      
-      console.log(`\n${isRecent ? chalk.green('●') : chalk.gray('○')} ${chalk.bold(backup.metadata.backupId)}`);
+
+      console.log(
+        `\n${isRecent ? chalk.green('●') : chalk.gray('○')} ${chalk.bold(backup.metadata.backupId)}`,
+      );
       console.log(`  ${chalk.gray('Date:')} ${date}`);
       console.log(`  ${chalk.gray('Type:')} ${type}`);
       console.log(`  ${chalk.gray('Files:')} ${fileCount}`);
-      
+
       if (backup.metadata.strategy) {
         console.log(`  ${chalk.gray('Strategy:')} ${backup.metadata.strategy}`);
       }
@@ -386,4 +402,4 @@ export class RollbackManager {
 
     console.log(chalk.gray('\n' + '─'.repeat(70)));
   }
-}
+}