claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.63

package/src/cli/simple-commands/init/rollback/backup-manager.js

@@ -28,7 +28,7 @@ export class BackupManager {
       location: null,
       errors: [],
       warnings: [],
-      files: []
+      files: [],
     };
 
     try {
@@ -52,7 +52,7 @@ export class BackupManager {
         timestamp: Date.now(),
         workingDir: this.workingDir,
         files: [],
-        directories: []
+        directories: [],
       };
 
       // Backup critical files
@@ -79,27 +79,20 @@ export class BackupManager {
       }
 
       // Save manifest
-      await Deno.writeTextFile(
-        `${backupPath}/manifest.json`,
-        JSON.stringify(manifest, null, 2)
-      );
+      await Deno.writeTextFile(`${backupPath}/manifest.json`, JSON.stringify(manifest, null, 2));
 
       // Create backup metadata
       const metadata = {
         created: Date.now(),
         size: await this.calculateBackupSize(backupPath),
         fileCount: manifest.files.length,
-        dirCount: manifest.directories.length
+        dirCount: manifest.directories.length,
       };
 
-      await Deno.writeTextFile(
-        `${backupPath}/metadata.json`,
-        JSON.stringify(metadata, null, 2)
-      );
+      await Deno.writeTextFile(`${backupPath}/metadata.json`, JSON.stringify(metadata, null, 2));
 
       console.log(`  ✓ Backup created: ${backupId}`);
       console.log(`  📁 Files backed up: ${result.files.length}`);
-
     } catch (error) {
       result.success = false;
       result.errors.push(`Backup creation failed: ${error.message}`);
@@ -116,12 +109,12 @@ export class BackupManager {
       success: true,
       errors: [],
       warnings: [],
-      restored: []
+      restored: [],
     };
 
     try {
       const backupPath = `${this.backupDir}/${backupId}`;
-      
+
       // Check if backup exists
       try {
         await Deno.stat(backupPath);
@@ -158,7 +151,6 @@ export class BackupManager {
 
       console.log(`  ✓ Backup restored: ${backupId}`);
       console.log(`  📁 Items restored: ${result.restored.length}`);
-
     } catch (error) {
       result.success = false;
       result.errors.push(`Backup restoration failed: ${error.message}`);
@@ -175,16 +167,16 @@ export class BackupManager {
 
     try {
       await this.ensureBackupDir();
-      
+
       for await (const entry of Deno.readDir(this.backupDir)) {
         if (entry.isDirectory) {
           try {
             const metadataPath = `${this.backupDir}/${entry.name}/metadata.json`;
             const manifestPath = `${this.backupDir}/${entry.name}/manifest.json`;
-            
+
             const metadata = JSON.parse(await Deno.readTextFile(metadataPath));
             const manifest = JSON.parse(await Deno.readTextFile(manifestPath));
-            
+
             backups.push({
               id: entry.name,
               type: manifest.type,
@@ -192,7 +184,7 @@ export class BackupManager {
               created: metadata.created,
               size: metadata.size,
               fileCount: metadata.fileCount,
-              dirCount: metadata.dirCount
+              dirCount: metadata.dirCount,
             });
           } catch {
             // Skip invalid backup directories
@@ -212,7 +204,7 @@ export class BackupManager {
   async deleteBackup(backupId) {
     const result = {
       success: true,
-      errors: []
+      errors: [],
     };
 
     try {
@@ -234,15 +226,15 @@ export class BackupManager {
     const result = {
       success: true,
       cleaned: [],
-      errors: []
+      errors: [],
     };
 
     try {
       const backups = await this.listBackups();
-      
+
       if (backups.length > keepCount) {
         const toDelete = backups.slice(keepCount);
-        
+
         for (const backup of toDelete) {
           const deleteResult = await this.deleteBackup(backup.id);
           if (deleteResult.success) {
@@ -252,7 +244,6 @@ export class BackupManager {
           }
         }
       }
-
     } catch (error) {
       result.success = false;
       result.errors.push(`Cleanup failed: ${error.message}`);
@@ -268,13 +259,13 @@ export class BackupManager {
     const result = {
       success: true,
       errors: [],
-      warnings: []
+      warnings: [],
     };
 
     try {
       // Check backup directory
       await this.ensureBackupDir();
-      
+
       // Test backup creation
       const testBackup = await this.createTestBackup();
       if (!testBackup.success) {
@@ -290,7 +281,6 @@ export class BackupManager {
       if (!spaceCheck.adequate) {
         result.warnings.push('Low disk space for backups');
       }
-
     } catch (error) {
       result.success = false;
       result.errors.push(`Backup system validation failed: ${error.message}`);
@@ -321,7 +311,7 @@ export class BackupManager {
       'package-lock.json',
       '.roomodes',
       'claude-flow',
-      'memory/claude-flow-data.json'
+      'memory/claude-flow-data.json',
     ];
 
     for (const file of potentialFiles) {
@@ -340,13 +330,7 @@ export class BackupManager {
 
   async getCriticalDirectories() {
     const dirs = [];
-    const potentialDirs = [
-      '.claude',
-      '.roo',
-      'memory/agents',
-      'memory/sessions',
-      'coordination'
-    ];
+    const potentialDirs = ['.claude', '.roo', 'memory/agents', 'memory/sessions', 'coordination'];
 
     for (const dir of potentialDirs) {
       try {
@@ -365,29 +349,28 @@ export class BackupManager {
   async backupFile(relativePath, backupPath) {
     const result = {
       success: true,
-      fileInfo: null
+      fileInfo: null,
     };
 
     try {
       const sourcePath = `${this.workingDir}/${relativePath}`;
       const destPath = `${backupPath}/${relativePath}`;
-      
+
       // Ensure destination directory exists
       const destDir = destPath.split('/').slice(0, -1).join('/');
       await Deno.mkdir(destDir, { recursive: true });
-      
+
       // Copy file
       await Deno.copyFile(sourcePath, destPath);
-      
+
       // Get file info
       const stat = await Deno.stat(sourcePath);
       result.fileInfo = {
         originalPath: relativePath,
         backupPath: destPath,
         size: stat.size,
-        modified: stat.mtime?.getTime() || 0
+        modified: stat.mtime?.getTime() || 0,
       };
-
     } catch (error) {
       result.success = false;
       result.error = error.message;
@@ -399,24 +382,23 @@ export class BackupManager {
   async backupDirectory(relativePath, backupPath) {
     const result = {
       success: true,
-      dirInfo: null
+      dirInfo: null,
     };
 
     try {
       const sourcePath = `${this.workingDir}/${relativePath}`;
       const destPath = `${backupPath}/${relativePath}`;
-      
+
       // Create destination directory
       await Deno.mkdir(destPath, { recursive: true });
-      
+
       // Copy directory contents recursively
       await this.copyDirectoryRecursive(sourcePath, destPath);
-      
+
       result.dirInfo = {
         originalPath: relativePath,
-        backupPath: destPath
+        backupPath: destPath,
       };
-
     } catch (error) {
       result.success = false;
       result.error = error.message;
@@ -429,7 +411,7 @@ export class BackupManager {
     for await (const entry of Deno.readDir(source)) {
       const sourcePath = `${source}/${entry.name}`;
       const destPath = `${dest}/${entry.name}`;
-      
+
       if (entry.isFile) {
         await Deno.copyFile(sourcePath, destPath);
       } else if (entry.isDirectory) {
@@ -441,20 +423,19 @@ export class BackupManager {
 
   async restoreFile(fileInfo, backupPath) {
     const result = {
-      success: true
+      success: true,
     };
 
     try {
       const sourcePath = fileInfo.backupPath;
       const destPath = `${this.workingDir}/${fileInfo.originalPath}`;
-      
+
       // Ensure destination directory exists
       const destDir = destPath.split('/').slice(0, -1).join('/');
       await Deno.mkdir(destDir, { recursive: true });
-      
+
       // Copy file back
       await Deno.copyFile(sourcePath, destPath);
-
     } catch (error) {
       result.success = false;
       result.error = error.message;
@@ -465,26 +446,25 @@ export class BackupManager {
 
   async restoreDirectory(dirInfo, backupPath) {
     const result = {
-      success: true
+      success: true,
     };
 
     try {
       const sourcePath = dirInfo.backupPath;
       const destPath = `${this.workingDir}/${dirInfo.originalPath}`;
-      
+
       // Remove existing directory if it exists
       try {
         await Deno.remove(destPath, { recursive: true });
       } catch {
         // Directory might not exist
       }
-      
+
       // Create destination directory
       await Deno.mkdir(destPath, { recursive: true });
-      
+
       // Copy directory contents back
       await this.copyDirectoryRecursive(sourcePath, destPath);
-
     } catch (error) {
       result.success = false;
       result.error = error.message;
@@ -500,7 +480,7 @@ export class BackupManager {
       for await (const entry of Deno.readDir(backupPath)) {
         const entryPath = `${backupPath}/${entry.name}`;
         const stat = await Deno.stat(entryPath);
-        
+
         if (stat.isFile) {
           totalSize += stat.size;
         } else if (stat.isDirectory) {
@@ -520,7 +500,7 @@ export class BackupManager {
     } catch (error) {
       return {
         success: false,
-        error: error.message
+        error: error.message,
       };
     }
   }
@@ -528,21 +508,21 @@ export class BackupManager {
   async checkBackupDiskSpace() {
     const result = {
       adequate: true,
-      available: 0
+      available: 0,
     };
 
     try {
       const command = new Deno.Command('df', {
         args: ['-k', this.backupDir],
-        stdout: 'piped'
+        stdout: 'piped',
       });
 
       const { stdout, success } = await command.output();
-      
+
       if (success) {
         const output = new TextDecoder().decode(stdout);
         const lines = output.trim().split('\n');
-        
+
         if (lines.length >= 2) {
           const parts = lines[1].split(/\s+/);
           if (parts.length >= 4) {
@@ -558,4 +538,4 @@ export class BackupManager {
 
     return result;
   }
-}
+}

package/src/cli/simple-commands/init/rollback/index.js

@@ -26,31 +26,30 @@ export class RollbackSystem {
       success: true,
       backupId: null,
       errors: [],
-      warnings: []
+      warnings: [],
     };
 
     try {
       console.log('🔄 Creating pre-initialization backup...');
-      
+
       const backup = await this.backupManager.createBackup('pre-init');
       result.backupId = backup.id;
       result.success = backup.success;
-      
+
       if (backup.success) {
         printSuccess(`Backup created: ${backup.id}`);
         console.log(`  📁 Backup location: ${backup.location}`);
-        
+
         // Record rollback point
         await this.stateTracker.recordRollbackPoint('pre-init', {
           backupId: backup.id,
           timestamp: Date.now(),
-          state: 'clean'
+          state: 'clean',
         });
       } else {
         result.errors.push(...backup.errors);
         printError('Failed to create backup');
       }
-
     } catch (error) {
       result.success = false;
       result.errors.push(`Backup creation failed: ${error.message}`);
@@ -67,7 +66,7 @@ export class RollbackSystem {
     const result = {
       success: true,
       checkpointId: null,
-      errors: []
+      errors: [],
     };
 
     try {
@@ -78,7 +77,6 @@ export class RollbackSystem {
       if (!checkpoint.success) {
         result.errors.push(...checkpoint.errors);
       }
-
     } catch (error) {
       result.success = false;
       result.errors.push(`Checkpoint creation failed: ${error.message}`);
@@ -95,14 +93,14 @@ export class RollbackSystem {
       success: true,
       errors: [],
       warnings: [],
-      actions: []
+      actions: [],
     };
 
     try {
       console.log('🔄 Performing full rollback...');
 
       // Find the appropriate backup
-      const targetBackup = backupId || await this.findLatestPreInitBackup();
+      const targetBackup = backupId || (await this.findLatestPreInitBackup());
       if (!targetBackup) {
         result.success = false;
         result.errors.push('No suitable backup found for rollback');
@@ -118,13 +116,12 @@ export class RollbackSystem {
 
       if (rollbackResult.success) {
         printSuccess('Full rollback completed successfully');
-        
+
         // Update state tracking
         await this.stateTracker.recordRollback(targetBackup, 'full');
       } else {
         printError('Full rollback failed');
       }
-
     } catch (error) {
       result.success = false;
       result.errors.push(`Rollback failed: ${error.message}`);
@@ -142,14 +139,14 @@ export class RollbackSystem {
       success: true,
       errors: [],
       warnings: [],
-      actions: []
+      actions: [],
     };
 
     try {
       console.log(`🔄 Performing partial rollback for phase: ${phase}`);
 
       // Find checkpoint
-      const checkpoint = checkpointId || await this.findLatestCheckpoint(phase);
+      const checkpoint = checkpointId || (await this.findLatestCheckpoint(phase));
       if (!checkpoint) {
         result.success = false;
         result.errors.push(`No checkpoint found for phase: ${phase}`);
@@ -165,13 +162,12 @@ export class RollbackSystem {
 
       if (rollbackResult.success) {
         printSuccess(`Partial rollback completed for phase: ${phase}`);
-        
+
         // Update state tracking
         await this.stateTracker.recordRollback(checkpoint, 'partial', phase);
       } else {
         printError(`Partial rollback failed for phase: ${phase}`);
       }
-
     } catch (error) {
       result.success = false;
       result.errors.push(`Partial rollback failed: ${error.message}`);
@@ -189,7 +185,7 @@ export class RollbackSystem {
       success: true,
       errors: [],
       warnings: [],
-      recoveryActions: []
+      recoveryActions: [],
     };
 
     try {
@@ -206,7 +202,6 @@ export class RollbackSystem {
       } else {
         printWarning(`Auto-recovery failed for: ${failureType}`);
       }
-
     } catch (error) {
       result.success = false;
       result.errors.push(`Auto-recovery failed: ${error.message}`);
@@ -224,7 +219,7 @@ export class RollbackSystem {
       success: true,
       rollbackPoints: [],
       checkpoints: [],
-      errors: []
+      errors: [],
     };
 
     try {
@@ -235,7 +230,6 @@ export class RollbackSystem {
       // Get checkpoints
       const checkpoints = await this.stateTracker.getCheckpoints();
       result.checkpoints = checkpoints;
-
     } catch (error) {
       result.success = false;
       result.errors.push(`Failed to list rollback points: ${error.message}`);
@@ -251,7 +245,7 @@ export class RollbackSystem {
     const result = {
       success: true,
       cleaned: [],
-      errors: []
+      errors: [],
     };
 
     try {
@@ -263,7 +257,6 @@ export class RollbackSystem {
       if (cleanupResult.success) {
         console.log(`🗑️  Cleaned up ${cleanupResult.cleaned.length} old backups`);
       }
-
     } catch (error) {
       result.success = false;
       result.errors.push(`Cleanup failed: ${error.message}`);
@@ -280,7 +273,7 @@ export class RollbackSystem {
       success: true,
       checks: {},
       errors: [],
-      warnings: []
+      warnings: [],
     };
 
     try {
@@ -305,7 +298,6 @@ export class RollbackSystem {
       if (!recoveryCheck.success) {
         result.warnings.push(...recoveryCheck.errors);
       }
-
     } catch (error) {
       result.success = false;
       result.errors.push(`Rollback system validation failed: ${error.message}`);
@@ -319,12 +311,12 @@ export class RollbackSystem {
   async findLatestPreInitBackup() {
     try {
       const rollbackPoints = await this.stateTracker.getRollbackPoints();
-      const preInitPoints = rollbackPoints.filter(point => point.type === 'pre-init');
-      
+      const preInitPoints = rollbackPoints.filter((point) => point.type === 'pre-init');
+
       if (preInitPoints.length > 0) {
         return preInitPoints.sort((a, b) => b.timestamp - a.timestamp)[0].backupId;
       }
-      
+
       return null;
     } catch {
       return null;
@@ -334,12 +326,12 @@ export class RollbackSystem {
   async findLatestCheckpoint(phase) {
     try {
       const checkpoints = await this.stateTracker.getCheckpoints();
-      const phaseCheckpoints = checkpoints.filter(checkpoint => checkpoint.phase === phase);
-      
+      const phaseCheckpoints = checkpoints.filter((checkpoint) => checkpoint.phase === phase);
+
       if (phaseCheckpoints.length > 0) {
         return phaseCheckpoints.sort((a, b) => b.timestamp - a.timestamp)[0];
       }
-      
+
       return null;
     } catch {
       return null;
@@ -362,11 +354,11 @@ export class AtomicOperation {
    * Begin atomic operation
    */
   async begin() {
-    const checkpoint = await this.rollbackSystem.createCheckpoint(
-      `atomic-${this.operationName}`,
-      { operation: this.operationName, started: Date.now() }
-    );
-    
+    const checkpoint = await this.rollbackSystem.createCheckpoint(`atomic-${this.operationName}`, {
+      operation: this.operationName,
+      started: Date.now(),
+    });
+
     this.checkpointId = checkpoint.checkpointId;
     return checkpoint.success;
   }
@@ -376,12 +368,12 @@ export class AtomicOperation {
    */
   async commit() {
     this.completed = true;
-    
+
     // Mark checkpoint as committed
     if (this.checkpointId) {
       await this.rollbackSystem.stateTracker.updateCheckpoint(this.checkpointId, {
         status: 'committed',
-        completed: Date.now()
+        completed: Date.now(),
       });
     }
   }
@@ -393,7 +385,7 @@ export class AtomicOperation {
     if (this.checkpointId && !this.completed) {
       await this.rollbackSystem.performPartialRollback(
         `atomic-${this.operationName}`,
-        this.checkpointId
+        this.checkpointId,
       );
     }
   }
@@ -404,4 +396,4 @@ export class AtomicOperation {
  */
 export function createAtomicOperation(rollbackSystem, operationName) {
   return new AtomicOperation(rollbackSystem, operationName);
-}
+}