claude-flow-novice 2.0.4 → 2.0.5

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

@@ -1,479 +1,542 @@
 // backup-manager.js - Backup creation and management
+
 // Node.js compatible import
-import fs from "fs";
-import { errors } from "../../../node-compat.js";
+import fs from 'fs';
+import { errors } from '../../../node-compat.js';
+
 // Polyfill for Deno's ensureDirSync
 function ensureDirSync(dirPath) {
-    try {
-        fs.mkdirSync(dirPath, {
-            recursive: true
-        });
-    } catch (error) {
-        if (error.code !== 'EEXIST') throw error;
-    }
+  try {
+    fs.mkdirSync(dirPath, { recursive: true });
+  } catch (error) {
+    if (error.code !== 'EEXIST') throw error;
+  }
 }
+
 export class BackupManager {
-    /**
+  constructor(workingDir) {
+    this.workingDir = workingDir;
+    this.backupDir = `${workingDir}/.claude-flow-backups`;
+  }
+
+  /**
    * Create a backup of the current state
-   */ async createBackup(type = 'manual', description = '') {
-        const result = {
-            success: true,
-            id: null,
-            location: null,
-            errors: [],
-            warnings: [],
-            files: []
-        };
-        try {
-            // Generate backup ID
-            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-            const backupId = `${type}-${timestamp}`;
-            result.id = backupId;
-            // Create backup directory
-            const backupPath = `${this.backupDir}/${backupId}`;
-            result.location = backupPath;
-            await this.ensureBackupDir();
-            await Deno.mkdir(backupPath, {
-                recursive: true
-            });
-            // Create backup manifest
-            const manifest = {
-                id: backupId,
-                type,
-                description,
-                timestamp: Date.now(),
-                workingDir: this.workingDir,
-                files: [],
-                directories: []
-            };
-            // Backup critical files
-            const criticalFiles = await this.getCriticalFiles();
-            for (const file of criticalFiles){
-                const backupResult = await this.backupFile(file, backupPath);
-                if (backupResult.success) {
-                    manifest.files.push(backupResult.fileInfo);
-                    result.files.push(file);
-                } else {
-                    result.warnings.push(`Failed to backup file: ${file}`);
-                }
-            }
-            // Backup critical directories
-            const criticalDirs = await this.getCriticalDirectories();
-            for (const dir of criticalDirs){
-                const backupResult = await this.backupDirectory(dir, backupPath);
-                if (backupResult.success) {
-                    manifest.directories.push(backupResult.dirInfo);
-                } else {
-                    result.warnings.push(`Failed to backup directory: ${dir}`);
-                }
-            }
-            // Save manifest
-            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
-            };
-            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}`);
+   */
+  async createBackup(type = 'manual', description = '') {
+    const result = {
+      success: true,
+      id: null,
+      location: null,
+      errors: [],
+      warnings: [],
+      files: [],
+    };
+
+    try {
+      // Generate backup ID
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupId = `${type}-${timestamp}`;
+      result.id = backupId;
+
+      // Create backup directory
+      const backupPath = `${this.backupDir}/${backupId}`;
+      result.location = backupPath;
+
+      await this.ensureBackupDir();
+      await Deno.mkdir(backupPath, { recursive: true });
+
+      // Create backup manifest
+      const manifest = {
+        id: backupId,
+        type,
+        description,
+        timestamp: Date.now(),
+        workingDir: this.workingDir,
+        files: [],
+        directories: [],
+      };
+
+      // Backup critical files
+      const criticalFiles = await this.getCriticalFiles();
+      for (const file of criticalFiles) {
+        const backupResult = await this.backupFile(file, backupPath);
+        if (backupResult.success) {
+          manifest.files.push(backupResult.fileInfo);
+          result.files.push(file);
+        } else {
+          result.warnings.push(`Failed to backup file: ${file}`);
         }
-        return result;
+      }
+
+      // Backup critical directories
+      const criticalDirs = await this.getCriticalDirectories();
+      for (const dir of criticalDirs) {
+        const backupResult = await this.backupDirectory(dir, backupPath);
+        if (backupResult.success) {
+          manifest.directories.push(backupResult.dirInfo);
+        } else {
+          result.warnings.push(`Failed to backup directory: ${dir}`);
+        }
+      }
+
+      // Save manifest
+      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,
+      };
+
+      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}`);
     }
-    /**
+
+    return result;
+  }
+
+  /**
    * Restore from backup
-   */ async restoreBackup(backupId) {
-        const result = {
-            success: true,
-            errors: [],
-            warnings: [],
-            restored: []
-        };
-        try {
-            const backupPath = `${this.backupDir}/${backupId}`;
-            // Check if backup exists
-            try {
-                await Deno.stat(backupPath);
-            } catch  {
-                result.success = false;
-                result.errors.push(`Backup not found: ${backupId}`);
-                return result;
-            }
-            // Read manifest
-            const manifestPath = `${backupPath}/manifest.json`;
-            const manifestContent = await fs.readFile(manifestPath, 'utf8');
-            const manifest = JSON.parse(manifestContent);
-            // Restore files
-            for (const fileInfo of manifest.files){
-                const restoreResult = await this.restoreFile(fileInfo, backupPath);
-                if (restoreResult.success) {
-                    result.restored.push(fileInfo.originalPath);
-                } else {
-                    result.warnings.push(`Failed to restore file: ${fileInfo.originalPath}`);
-                }
-            }
-            // Restore directories
-            for (const dirInfo of manifest.directories){
-                const restoreResult = await this.restoreDirectory(dirInfo, backupPath);
-                if (restoreResult.success) {
-                    result.restored.push(dirInfo.originalPath);
-                } else {
-                    result.warnings.push(`Failed to restore directory: ${dirInfo.originalPath}`);
-                }
-            }
-            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}`);
-        }
+   */
+  async restoreBackup(backupId) {
+    const result = {
+      success: true,
+      errors: [],
+      warnings: [],
+      restored: [],
+    };
+
+    try {
+      const backupPath = `${this.backupDir}/${backupId}`;
+
+      // Check if backup exists
+      try {
+        await Deno.stat(backupPath);
+      } catch {
+        result.success = false;
+        result.errors.push(`Backup not found: ${backupId}`);
         return result;
+      }
+
+      // Read manifest
+      const manifestPath = `${backupPath}/manifest.json`;
+      const manifestContent = await fs.readFile(manifestPath, 'utf8');
+      const manifest = JSON.parse(manifestContent);
+
+      // Restore files
+      for (const fileInfo of manifest.files) {
+        const restoreResult = await this.restoreFile(fileInfo, backupPath);
+        if (restoreResult.success) {
+          result.restored.push(fileInfo.originalPath);
+        } else {
+          result.warnings.push(`Failed to restore file: ${fileInfo.originalPath}`);
+        }
+      }
+
+      // Restore directories
+      for (const dirInfo of manifest.directories) {
+        const restoreResult = await this.restoreDirectory(dirInfo, backupPath);
+        if (restoreResult.success) {
+          result.restored.push(dirInfo.originalPath);
+        } else {
+          result.warnings.push(`Failed to restore directory: ${dirInfo.originalPath}`);
+        }
+      }
+
+      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}`);
     }
-    /**
+
+    return result;
+  }
+
+  /**
    * List available backups
-   */ async listBackups() {
-        const backups = [];
-        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 fs.readFile(metadataPath, 'utf8'));
-                        const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
-                        backups.push({
-                            id: entry.name,
-                            type: manifest.type,
-                            description: manifest.description,
-                            created: metadata.created,
-                            size: metadata.size,
-                            fileCount: metadata.fileCount,
-                            dirCount: metadata.dirCount
-                        });
-                    } catch  {
-                    // Skip invalid backup directories
-                    }
-                }
-            }
-        } catch  {
-        // Backup directory doesn't exist or can't be read
+   */
+  async listBackups() {
+    const backups = [];
+
+    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 fs.readFile(metadataPath, 'utf8'));
+            const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+
+            backups.push({
+              id: entry.name,
+              type: manifest.type,
+              description: manifest.description,
+              created: metadata.created,
+              size: metadata.size,
+              fileCount: metadata.fileCount,
+              dirCount: metadata.dirCount,
+            });
+          } catch {
+            // Skip invalid backup directories
+          }
         }
-        return backups.sort((a, b)=>b.created - a.created);
+      }
+    } catch {
+      // Backup directory doesn't exist or can't be read
     }
-    /**
+
+    return backups.sort((a, b) => b.created - a.created);
+  }
+
+  /**
    * Delete a backup
-   */ async deleteBackup(backupId) {
-        const result = {
-            success: true,
-            errors: []
-        };
-        try {
-            const backupPath = `${this.backupDir}/${backupId}`;
-            await Deno.remove(backupPath, {
-                recursive: true
-            });
-            console.log(`  🗑️  Deleted backup: ${backupId}`);
-        } catch (error) {
-            result.success = false;
-            result.errors.push(`Failed to delete backup: ${error.message}`);
-        }
-        return result;
+   */
+  async deleteBackup(backupId) {
+    const result = {
+      success: true,
+      errors: [],
+    };
+
+    try {
+      const backupPath = `${this.backupDir}/${backupId}`;
+      await Deno.remove(backupPath, { recursive: true });
+      console.log(`  🗑️  Deleted backup: ${backupId}`);
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Failed to delete backup: ${error.message}`);
     }
-    /**
+
+    return result;
+  }
+
+  /**
    * Clean up old backups
-   */ async cleanupOldBackups(keepCount = 5) {
-        const result = {
-            success: true,
-            cleaned: [],
-            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) {
-                        result.cleaned.push(backup.id);
-                    } else {
-                        result.errors.push(...deleteResult.errors);
-                    }
-                }
-            }
-        } catch (error) {
-            result.success = false;
-            result.errors.push(`Cleanup failed: ${error.message}`);
+   */
+  async cleanupOldBackups(keepCount = 5) {
+    const result = {
+      success: true,
+      cleaned: [],
+      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) {
+            result.cleaned.push(backup.id);
+          } else {
+            result.errors.push(...deleteResult.errors);
+          }
         }
-        return result;
+      }
+    } catch (error) {
+      result.success = false;
+      result.errors.push(`Cleanup failed: ${error.message}`);
     }
-    /**
+
+    return result;
+  }
+
+  /**
    * Validate backup system
-   */ async validateBackupSystem() {
-        const result = {
-            success: true,
-            errors: [],
-            warnings: []
-        };
-        try {
-            // Check backup directory
-            await this.ensureBackupDir();
-            // Test backup creation
-            const testBackup = await this.createTestBackup();
-            if (!testBackup.success) {
-                result.success = false;
-                result.errors.push('Cannot create test backup');
-            } else {
-                // Clean up test backup
-                await this.deleteBackup(testBackup.id);
-            }
-            // Check disk space
-            const spaceCheck = await this.checkBackupDiskSpace();
-            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}`);
-        }
-        return result;
+   */
+  async validateBackupSystem() {
+    const result = {
+      success: true,
+      errors: [],
+      warnings: [],
+    };
+
+    try {
+      // Check backup directory
+      await this.ensureBackupDir();
+
+      // Test backup creation
+      const testBackup = await this.createTestBackup();
+      if (!testBackup.success) {
+        result.success = false;
+        result.errors.push('Cannot create test backup');
+      } else {
+        // Clean up test backup
+        await this.deleteBackup(testBackup.id);
+      }
+
+      // Check disk space
+      const spaceCheck = await this.checkBackupDiskSpace();
+      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}`);
     }
-    // Helper methods
-    async ensureBackupDir() {
-        try {
-            await Deno.mkdir(this.backupDir, {
-                recursive: true
-            });
-        } catch (error) {
-            if (!(error instanceof errors.AlreadyExists)) {
-                throw error;
-            }
-        }
+
+    return result;
+  }
+
+  // Helper methods
+
+  async ensureBackupDir() {
+    try {
+      await Deno.mkdir(this.backupDir, { recursive: true });
+    } catch (error) {
+      if (!(error instanceof errors.AlreadyExists)) {
+        throw error;
+      }
     }
-    async getCriticalFiles() {
-        const files = [];
-        const potentialFiles = [
-            'CLAUDE.md',
-            'memory-bank.md',
-            'coordination.md',
-            'package.json',
-            'package-lock.json',
-            '.roomodes',
-            'claude-flow',
-            'memory/claude-flow-data.json'
-        ];
-        for (const file of potentialFiles){
-            try {
-                const stat = await Deno.stat(`${this.workingDir}/${file}`);
-                if (stat.isFile) {
-                    files.push(file);
-                }
-            } catch  {
-            // File doesn't exist
-            }
+  }
+
+  async getCriticalFiles() {
+    const files = [];
+    const potentialFiles = [
+      'CLAUDE.md',
+      'memory-bank.md',
+      'coordination.md',
+      'package.json',
+      'package-lock.json',
+      '.roomodes',
+      'claude-flow',
+      'memory/claude-flow-data.json',
+    ];
+
+    for (const file of potentialFiles) {
+      try {
+        const stat = await Deno.stat(`${this.workingDir}/${file}`);
+        if (stat.isFile) {
+          files.push(file);
         }
-        return files;
+      } catch {
+        // File doesn't exist
+      }
     }
-    async getCriticalDirectories() {
-        const dirs = [];
-        const potentialDirs = [
-            '.claude',
-            '.roo',
-            'memory/agents',
-            'memory/sessions',
-            'coordination'
-        ];
-        for (const dir of potentialDirs){
-            try {
-                const stat = await Deno.stat(`${this.workingDir}/${dir}`);
-                if (stat.isDirectory) {
-                    dirs.push(dir);
-                }
-            } catch  {
-            // Directory doesn't exist
-            }
+
+    return files;
+  }
+
+  async getCriticalDirectories() {
+    const dirs = [];
+    const potentialDirs = ['.claude', '.roo', 'memory/agents', 'memory/sessions', 'coordination'];
+
+    for (const dir of potentialDirs) {
+      try {
+        const stat = await Deno.stat(`${this.workingDir}/${dir}`);
+        if (stat.isDirectory) {
+          dirs.push(dir);
         }
-        return dirs;
+      } catch {
+        // Directory doesn't exist
+      }
     }
-    async backupFile(relativePath, backupPath) {
-        const result = {
-            success: true,
-            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
-            };
-        } catch (error) {
-            result.success = false;
-            result.error = error.message;
-        }
-        return result;
+
+    return dirs;
+  }
+
+  async backupFile(relativePath, backupPath) {
+    const result = {
+      success: true,
+      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,
+      };
+    } catch (error) {
+      result.success = false;
+      result.error = error.message;
     }
-    async backupDirectory(relativePath, backupPath) {
-        const result = {
-            success: true,
-            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
-            };
-        } catch (error) {
-            result.success = false;
-            result.error = error.message;
-        }
-        return result;
+
+    return result;
+  }
+
+  async backupDirectory(relativePath, backupPath) {
+    const result = {
+      success: true,
+      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,
+      };
+    } catch (error) {
+      result.success = false;
+      result.error = error.message;
     }
-    async copyDirectoryRecursive(source, dest) {
-        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) {
-                await Deno.mkdir(destPath, {
-                    recursive: true
-                });
-                await this.copyDirectoryRecursive(sourcePath, destPath);
-            }
-        }
+
+    return result;
+  }
+
+  async copyDirectoryRecursive(source, dest) {
+    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) {
+        await Deno.mkdir(destPath, { recursive: true });
+        await this.copyDirectoryRecursive(sourcePath, destPath);
+      }
     }
-    async restoreFile(fileInfo, backupPath) {
-        const result = {
-            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;
-        }
-        return result;
+  }
+
+  async restoreFile(fileInfo, backupPath) {
+    const result = {
+      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;
     }
-    async restoreDirectory(dirInfo, backupPath) {
-        const result = {
-            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;
-        }
-        return result;
+
+    return result;
+  }
+
+  async restoreDirectory(dirInfo, backupPath) {
+    const result = {
+      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;
     }
-    async calculateBackupSize(backupPath) {
-        let totalSize = 0;
-        try {
-            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) {
-                    totalSize += await this.calculateBackupSize(entryPath);
-                }
-            }
-        } catch  {
-        // Error calculating size
+
+    return result;
+  }
+
+  async calculateBackupSize(backupPath) {
+    let totalSize = 0;
+
+    try {
+      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) {
+          totalSize += await this.calculateBackupSize(entryPath);
         }
-        return totalSize;
+      }
+    } catch {
+      // Error calculating size
     }
-    async createTestBackup() {
-        try {
-            return await this.createBackup('test', 'System validation test');
-        } catch (error) {
-            return {
-                success: false,
-                error: error.message
-            };
-        }
+
+    return totalSize;
+  }
+
+  async createTestBackup() {
+    try {
+      return await this.createBackup('test', 'System validation test');
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+      };
     }
-    async checkBackupDiskSpace() {
-        const result = {
-            adequate: true,
-            available: 0
-        };
-        try {
-            const command = new Deno.Command('df', {
-                args: [
-                    '-k',
-                    this.backupDir
-                ],
-                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) {
-                        result.available = parseInt(parts[3]) / 1024; // MB
-                        result.adequate = result.available > 500; // At least 500MB for backups
-                    }
-                }
-            }
-        } catch  {
-            // Can't check - assume adequate
-            result.adequate = true;
+  }
+
+  async checkBackupDiskSpace() {
+    const result = {
+      adequate: true,
+      available: 0,
+    };
+
+    try {
+      const command = new Deno.Command('df', {
+        args: ['-k', this.backupDir],
+        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) {
+            result.available = parseInt(parts[3]) / 1024; // MB
+            result.adequate = result.available > 500; // At least 500MB for backups
+          }
         }
-        return result;
-    }
-    constructor(workingDir){
-        this.workingDir = workingDir;
-        this.backupDir = `${workingDir}/.claude-flow-backups`;
+      }
+    } catch {
+      // Can't check - assume adequate
+      result.adequate = true;
     }
+
+    return result;
+  }
 }