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

package/src/swarm/prompt-copier-enhanced.ts

@@ -1,7 +1,6 @@
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
-import { getErrorMessage } from '../utils/error-handler.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { Worker } from 'worker_threads';
@@ -25,10 +24,10 @@ export class EnhancedPromptCopier extends PromptCopier {
 
   public async copyFilesParallel(): Promise<void> {
     const workerCount = Math.min((this as any).options.maxWorkers, (this as any).fileQueue.length);
-    
+
     // Initialize worker pool
     this.workerPool = await this.initializeWorkerPool(workerCount);
-    
+
     try {
       // Process files using worker pool
       await this.processWithWorkerPool();
@@ -43,114 +42,114 @@ export class EnhancedPromptCopier extends PromptCopier {
     const pool: WorkerPool = {
       workers,
       busy: new Set(),
-      queue: []
+      queue: [],
     };
-    
+
     // Create workers
     for (let i = 0; i < workerCount; i++) {
-      const worker = new Worker(
-        path.join(__dirname, 'workers', 'copy-worker.js'),
-        {
-          workerData: { workerId: i }
-        }
-      );
-      
+      const worker = new Worker(path.join(__dirname, 'workers', 'copy-worker.js'), {
+        workerData: { workerId: i },
+      });
+
       // Setup worker message handler
       worker.on('message', (result) => {
         this.handleWorkerResult(result, i, pool);
       });
-      
+
       worker.on('error', (error) => {
         logger.error(`Worker ${i} error:`, error);
         (this as any).errors.push({
           file: 'worker',
-          error: (error instanceof Error ? error.message : String(error)),
-          phase: 'write'
+          error: error instanceof Error ? error.message : String(error),
+          phase: 'write',
         });
       });
-      
+
       workers.push(worker);
     }
-    
+
     return pool;
   }
 
   private async processWithWorkerPool(): Promise<void> {
-    const chunkSize = Math.max(1, Math.floor((this as any).fileQueue.length / this.workerPool!.workers.length / 2));
+    const chunkSize = Math.max(
+      1,
+      Math.floor((this as any).fileQueue.length / this.workerPool!.workers.length / 2),
+    );
     const chunks: FileInfo[][] = [];
-    
+
     // Create chunks for better distribution
     for (let i = 0; i < (this as any).fileQueue.length; i += chunkSize) {
       chunks.push((this as any).fileQueue.slice(i, i + chunkSize));
     }
-    
+
     // Process chunks
     const promises: Promise<void>[] = [];
-    
+
     for (const chunk of chunks) {
       promises.push(this.processChunkWithWorker(chunk));
     }
-    
+
     await Promise.all(promises);
   }
 
   private async processChunkWithWorker(chunk: FileInfo[]): Promise<void> {
     return new Promise((resolve, reject) => {
       const pool = this.workerPool!;
-      
+
       const tryAssignWork = () => {
         // Find available worker
         const availableWorkerIndex = pool.workers.findIndex((_, index) => !pool.busy.has(index));
-        
+
         if (availableWorkerIndex === -1) {
           // No workers available, queue the work
           pool.queue.push(tryAssignWork);
           return;
         }
-        
+
         // Mark worker as busy
         pool.busy.add(availableWorkerIndex);
-        
+
         // Prepare worker data
         const workerData = {
-          files: chunk.map(file => ({
+          files: chunk.map((file) => ({
             sourcePath: file.path,
             destPath: path.join((this as any).options.destination, file.relativePath),
             permissions: (this as any).options.preservePermissions ? file.permissions : undefined,
-            verify: (this as any).options.verify
+            verify: (this as any).options.verify,
           })),
-          workerId: availableWorkerIndex
+          workerId: availableWorkerIndex,
         };
-        
+
         let remainingFiles = chunk.length;
         const chunkResults: any[] = [];
-        
+
         // Setup temporary message handler for this chunk
         const messageHandler = (result: any) => {
           chunkResults.push(result);
           remainingFiles--;
-          
+
           if (remainingFiles === 0) {
             // Chunk complete
             pool.workers[availableWorkerIndex].off('message', messageHandler);
             pool.busy.delete(availableWorkerIndex);
-            
+
             // Process next queued work
             if (pool.queue.length > 0) {
               const nextWork = pool.queue.shift()!;
               nextWork();
             }
-            
+
             // Process results
             this.processChunkResults(chunk, chunkResults);
             resolve();
           }
         };
-        
+
         pool.workers[availableWorkerIndex].on('message', messageHandler);
         pool.workers[availableWorkerIndex].postMessage(workerData);
       };
-      
+
       tryAssignWork();
     });
   }
@@ -166,14 +165,17 @@ export class EnhancedPromptCopier extends PromptCopier {
         (this as any).errors.push({
           file: result.file,
           error: result.error,
-          phase: 'write'
+          phase: 'write',
         });
       }
     }
-    
+
     // Report progress through the callback if available
     if ((this as any).options.progressCallback) {
-      (this as any).options.progressCallback((this as any).copiedFiles.size, (this as any).totalFiles);
+      (this as any).options.progressCallback(
+        (this as any).copiedFiles.size,
+        (this as any).totalFiles,
+      );
     }
   }
 
@@ -184,11 +186,9 @@ export class EnhancedPromptCopier extends PromptCopier {
 
   private async terminateWorkers(): Promise<void> {
     if (!this.workerPool) return;
-    
-    const terminationPromises = this.workerPool.workers.map(worker => 
-      worker.terminate()
-    );
-    
+
+    const terminationPromises = this.workerPool.workers.map((worker) => worker.terminate());
+
     await Promise.all(terminationPromises);
     this.workerPool = undefined;
   }
@@ -196,26 +196,26 @@ export class EnhancedPromptCopier extends PromptCopier {
   // Override verification to use worker results
   protected override async verifyFiles(): Promise<void> {
     logger.info('Verifying copied files...');
-    
+
     for (const file of (this as any).fileQueue) {
       if (!(this as any).copiedFiles.has(file.path)) continue;
-      
+
       try {
         const destPath = path.join((this as any).options.destination, file.relativePath);
-        
+
         // Verify file exists
-        if (!await (this as any).fileExists(destPath)) {
+        if (!(await (this as any).fileExists(destPath))) {
           throw new Error('Destination file not found');
         }
-        
+
         // Verify size
         const destStats = await fs.stat(destPath);
         const sourceStats = await fs.stat(file.path);
-        
+
         if (destStats.size !== sourceStats.size) {
           throw new Error(`Size mismatch: ${destStats.size} != ${sourceStats.size}`);
         }
-        
+
         // Use hash from worker if available
         const workerResult = this.workerResults.get(file.path);
         if (workerResult?.hash) {
@@ -224,12 +224,11 @@ export class EnhancedPromptCopier extends PromptCopier {
             throw new Error(`Hash mismatch: ${sourceHash} != ${workerResult.hash}`);
           }
         }
-        
       } catch (error) {
         (this as any).errors.push({
           file: file.path,
-          error: (error instanceof Error ? error.message : String(error)),
-          phase: 'verify'
+          error: error instanceof Error ? error.message : String(error),
+          phase: 'verify',
         });
       }
     }
@@ -240,4 +239,4 @@ export class EnhancedPromptCopier extends PromptCopier {
 export async function copyPromptsEnhanced(options: CopyOptions): Promise<CopyResult> {
   const copier = new EnhancedPromptCopier(options);
   return copier.copy();
-}
+}

package/src/swarm/prompt-copier.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { createHash } from 'crypto';
@@ -78,18 +77,18 @@ export class PromptCopier extends EventEmitter {
       maxWorkers: options.maxWorkers ?? 4,
       dryRun: options.dryRun ?? false,
       conflictResolution: options.conflictResolution ?? 'backup',
-      progressCallback: options.progressCallback ?? (() => {})
+      progressCallback: options.progressCallback ?? (() => {}),
     };
   }
 
   async copy(): Promise<CopyResult> {
     const startTime = Date.now();
-    
+
     try {
       // Phase 1: Discovery
       logger.info('Starting prompt discovery phase...');
       await this.discoverFiles();
-      
+
       if (this.fileQueue.length === 0) {
         return {
           success: true,
@@ -98,8 +97,8 @@ export class PromptCopier extends EventEmitter {
           failedFiles: 0,
           skippedFiles: 0,
           duration: Date.now() - startTime,
-      errors: []
-    };
+          errors: [],
+        };
       }
 
       // Phase 2: Pre-flight checks
@@ -128,7 +127,7 @@ export class PromptCopier extends EventEmitter {
         failedFiles: this.errors.length,
         skippedFiles: this.fileQueue.length - this.copiedFiles.size - this.errors.length,
         errors: this.errors,
-        duration
+        duration,
       };
 
       if (this.backupMap.size > 0) {
@@ -137,38 +136,37 @@ export class PromptCopier extends EventEmitter {
 
       logger.info(`Copy completed in ${duration}ms`, result);
       return result;
-
     } catch (error) {
       logger.error('Copy operation failed', error);
-      
+
       if (!this.options.dryRun) {
         await this.rollback();
       }
-      
+
       throw error;
     }
   }
 
   private async discoverFiles(): Promise<void> {
     const sourceStats = await fs.stat(this.options.source);
-    
+
     if (!sourceStats.isDirectory()) {
       throw new Error(`Source path ${this.options.source} is not a directory`);
     }
 
     await this.scanDirectory(this.options.source, '');
-    
+
     // Sort by size for better parallel distribution
     this.fileQueue.sort((a, b) => b.size - a.size);
   }
 
   private async scanDirectory(dirPath: string, relativePath: string): Promise<void> {
     const entries = await fs.readdir(dirPath, { withFileTypes: true });
-    
+
     for (const entry of entries) {
       const fullPath = path.join(dirPath, entry.name);
       const relPath = path.join(relativePath, entry.name);
-      
+
       if (entry.isDirectory()) {
         await this.scanDirectory(fullPath, relPath);
       } else if (entry.isFile() && this.shouldIncludeFile(relPath)) {
@@ -177,7 +175,7 @@ export class PromptCopier extends EventEmitter {
           path: fullPath,
           relativePath: relPath,
           size: stats.size,
-          permissions: stats.mode
+          permissions: stats.mode,
         });
       }
     }
@@ -190,42 +188,39 @@ export class PromptCopier extends EventEmitter {
         return false;
       }
     }
-    
+
     // Check include patterns
     if (this.options.includePatterns.length === 0) {
       return true;
     }
-    
+
     for (const pattern of this.options.includePatterns) {
       if (this.matchPattern(filePath, pattern)) {
         return true;
       }
     }
-    
+
     return false;
   }
 
   private matchPattern(filePath: string, pattern: string): boolean {
     // Simple glob pattern matching
-    const regex = pattern
-      .replace(/\./g, '\\.')
-      .replace(/\*/g, '.*')
-      .replace(/\?/g, '.');
-    
+    const regex = pattern.replace(/\./g, '\\.').replace(/\*/g, '.*').replace(/\?/g, '.');
+
     return new RegExp(regex).test(filePath);
   }
 
   private async ensureDestinationDirectories(): Promise<void> {
     const directories = new Set<string>();
-    
+
     for (const file of this.fileQueue) {
       const destDir = path.dirname(path.join(this.options.destination, file.relativePath));
       directories.add(destDir);
     }
-    
+
     // Create directories in order (parent first)
     const sortedDirs = Array.from(directories).sort((a, b) => a.length - b.length);
-    
+
     for (const dir of sortedDirs) {
       await fs.mkdir(dir, { recursive: true });
     }
@@ -233,7 +228,7 @@ export class PromptCopier extends EventEmitter {
 
   private async copyFilesSequential(): Promise<void> {
     let completed = 0;
-    
+
     for (const file of this.fileQueue) {
       try {
         await this.copyFile(file);
@@ -242,8 +237,8 @@ export class PromptCopier extends EventEmitter {
       } catch (error) {
         this.errors.push({
           file: file.path,
-          error: (error instanceof Error ? error.message : String(error)),
-          phase: 'write'
+          error: error instanceof Error ? error.message : String(error),
+          phase: 'write',
         });
       }
     }
@@ -253,17 +248,17 @@ export class PromptCopier extends EventEmitter {
     const workerCount = Math.min(this.options.maxWorkers, this.fileQueue.length);
     const chunkSize = Math.ceil(this.fileQueue.length / workerCount);
     const workers: Promise<void>[] = [];
-    
+
     for (let i = 0; i < workerCount; i++) {
       const start = i * chunkSize;
       const end = Math.min(start + chunkSize, this.fileQueue.length);
       const chunk = this.fileQueue.slice(start, end);
-      
+
       if (chunk.length > 0) {
         workers.push(this.processChunk(chunk, i));
       }
     }
-    
+
     await Promise.all(workers);
   }
 
@@ -276,8 +271,8 @@ export class PromptCopier extends EventEmitter {
       } catch (error) {
         this.errors.push({
           file: file.path,
-          error: (error instanceof Error ? error.message : String(error)),
-          phase: 'write'
+          error: error instanceof Error ? error.message : String(error),
+          phase: 'write',
         });
       }
     }
@@ -285,7 +280,7 @@ export class PromptCopier extends EventEmitter {
 
   private async copyFile(file: FileInfo): Promise<void> {
     const destPath = path.join(this.options.destination, file.relativePath);
-    
+
     if (this.options.dryRun) {
       logger.info(`[DRY RUN] Would copy ${file.path} to ${destPath}`);
       return;
@@ -293,21 +288,21 @@ export class PromptCopier extends EventEmitter {
 
     // Check for conflicts
     const destExists = await this.fileExists(destPath);
-    
+
     if (destExists) {
       switch (this.options.conflictResolution) {
         case 'skip':
           logger.info(`Skipping existing file: ${destPath}`);
           return;
-          
+
         case 'backup':
           await this.backupFile(destPath);
           break;
-          
+
         case 'merge':
           await this.mergeFiles(file.path, destPath);
           return;
-          
+
         case 'overwrite':
           // Continue with copy
           break;
@@ -321,7 +316,7 @@ export class PromptCopier extends EventEmitter {
 
     // Copy the file
     await fs.copyFile(file.path, destPath);
-    
+
     // Preserve permissions if requested
     if (this.options.preservePermissions && file.permissions) {
       await fs.chmod(destPath, file.permissions);
@@ -345,11 +340,11 @@ export class PromptCopier extends EventEmitter {
   private async backupFile(filePath: string): Promise<void> {
     const backupDir = path.join(this.options.destination, '.prompt-backups');
     await fs.mkdir(backupDir, { recursive: true });
-    
+
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
     const backupName = `${path.basename(filePath)}.${timestamp}.bak`;
     const backupPath = path.join(backupDir, backupName);
-    
+
     await fs.copyFile(filePath, backupPath);
     this.backupMap.set(filePath, backupPath);
   }
@@ -358,36 +353,36 @@ export class PromptCopier extends EventEmitter {
     // Simple merge strategy: append source to destination with separator
     const sourceContent = await fs.readFile(sourcePath, 'utf-8');
     const destContent = await fs.readFile(destPath, 'utf-8');
-    
+
     const separator = '\n\n--- MERGED CONTENT ---\n\n';
     const mergedContent = destContent + separator + sourceContent;
-    
+
     await this.backupFile(destPath);
     await fs.writeFile(destPath, mergedContent, 'utf-8');
   }
 
   private async verifyFiles(): Promise<void> {
     logger.info('Verifying copied files...');
-    
+
     for (const file of this.fileQueue) {
       if (!this.copiedFiles.has(file.path)) continue;
-      
+
       try {
         const destPath = path.join(this.options.destination, file.relativePath);
-        
+
         // Verify file exists
-        if (!await this.fileExists(destPath)) {
+        if (!(await this.fileExists(destPath))) {
           throw new Error('Destination file not found');
         }
-        
+
         // Verify size
         const destStats = await fs.stat(destPath);
         const sourceStats = await fs.stat(file.path);
-        
+
         if (destStats.size !== sourceStats.size) {
           throw new Error(`Size mismatch: ${destStats.size} != ${sourceStats.size}`);
         }
-        
+
         // Verify hash if available
         if (file.hash) {
           const destHash = await this.calculateFileHash(destPath);
@@ -395,12 +390,11 @@ export class PromptCopier extends EventEmitter {
             throw new Error(`Hash mismatch: ${destHash} != ${file.hash}`);
           }
         }
-        
       } catch (error) {
         this.errors.push({
           file: file.path,
-          error: (error instanceof Error ? error.message : String(error)),
-          phase: 'verify'
+          error: error instanceof Error ? error.message : String(error),
+          phase: 'verify',
         });
       }
     }
@@ -424,26 +418,26 @@ export class PromptCopier extends EventEmitter {
     const manifestPath = path.join(
       this.options.destination,
       '.prompt-backups',
-      `manifest-${Date.now()}.json`
+      `manifest-${Date.now()}.json`,
     );
-    
+
     const manifest = {
       timestamp: new Date().toISOString(),
       source: this.options.source,
       destination: this.options.destination,
       backups: Array.from(this.backupMap.entries()).map(([original, backup]) => ({
         original,
-        backup
-      }))
+        backup,
+      })),
     };
-    
+
     await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
     return manifestPath;
   }
 
   private async rollback(): Promise<void> {
     logger.warn('Rolling back changes...');
-    
+
     // Execute rollback operations in reverse order
     for (let i = this.rollbackStack.length - 1; i >= 0; i--) {
       try {
@@ -452,7 +446,7 @@ export class PromptCopier extends EventEmitter {
         logger.error(`Rollback operation ${i} failed:`, error);
       }
     }
-    
+
     // Clean up backup directory if empty
     try {
       const backupDir = path.join(this.options.destination, '.prompt-backups');
@@ -471,9 +465,9 @@ export class PromptCopier extends EventEmitter {
       completed,
       failed: this.errors.length,
       skipped: this.fileQueue.length - completed - this.errors.length,
-      percentage: Math.round((completed / this.fileQueue.length) * 100)
+      percentage: Math.round((completed / this.fileQueue.length) * 100),
     };
-    
+
     this.emit('progress', progress);
     this.options.progressCallback(progress);
   }
@@ -481,7 +475,7 @@ export class PromptCopier extends EventEmitter {
   // Utility method to restore from backup
   async restoreFromBackup(manifestPath: string): Promise<void> {
     const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
-    
+
     for (const { original, backup } of manifest.backups) {
       try {
         await fs.copyFile(backup, original);
@@ -497,4 +491,4 @@ export class PromptCopier extends EventEmitter {
 export async function copyPrompts(options: CopyOptions): Promise<CopyResult> {
   const copier = new PromptCopier(options);
   return copier.copy();
-}
+}