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

package/src/swarm/optimizations/async-file-manager.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../../utils/error-handler.js';
 /**
  * Async File Manager
  * Handles non-blocking file operations with queuing
@@ -28,116 +27,113 @@ export class AsyncFileManager {
   private metrics = {
     operations: new Map<string, number>(),
     totalBytes: 0,
-    errors: 0
+    errors: 0,
   };
-  
+
   constructor(
     private concurrency = {
       write: 10,
-      read: 20
-    }
+      read: 20,
+    },
   ) {
     this.writeQueue = new PQueue({ concurrency: this.concurrency.write });
     this.readQueue = new PQueue({ concurrency: this.concurrency.read });
-    
+
     // Use test-safe logger configuration
-    const loggerConfig = process.env.CLAUDE_FLOW_ENV === 'test' 
-      ? { level: 'error' as const, format: 'json' as const, destination: 'console' as const }
-      : { level: 'info' as const, format: 'json' as const, destination: 'console' as const };
-    
-    this.logger = new Logger(
-      loggerConfig,
-      { component: 'AsyncFileManager' }
-    );
+    const loggerConfig =
+      process.env.CLAUDE_FLOW_ENV === 'test'
+        ? { level: 'error' as const, format: 'json' as const, destination: 'console' as const }
+        : { level: 'info' as const, format: 'json' as const, destination: 'console' as const };
+
+    this.logger = new Logger(loggerConfig, { component: 'AsyncFileManager' });
   }
-  
+
   async writeFile(path: string, data: string | Buffer): Promise<FileOperationResult> {
     const start = Date.now();
-    
+
     return await this.writeQueue.add(async () => {
       try {
         // Ensure directory exists
         await this.ensureDirectory(dirname(path));
-        
+
         // Use streaming for large files
-        if (data.length > 1024 * 1024) { // > 1MB
+        if (data.length > 1024 * 1024) {
+          // > 1MB
           await this.streamWrite(path, data);
         } else {
           await fs.writeFile(path, data, 'utf8');
         }
-        
+
         const duration = Date.now() - start;
         const size = Buffer.byteLength(data);
-        
+
         this.trackOperation('write', size);
-        
+
         return {
           path,
           operation: 'write' as const,
           success: true,
           duration,
-          size
+          size,
         };
       } catch (error) {
         this.metrics.errors++;
         this.logger.error('Failed to write file', { path, error });
-        
+
         return {
           path,
           operation: 'write' as const,
           success: false,
           duration: Date.now() - start,
-          error: error as Error
+          error: error as Error,
         };
       }
     });
   }
-  
+
   async readFile(path: string): Promise<FileOperationResult & { data?: string }> {
     const start = Date.now();
-    
+
     return await this.readQueue.add(async () => {
       try {
         const data = await fs.readFile(path, 'utf8');
         const duration = Date.now() - start;
         const size = Buffer.byteLength(data);
-        
+
         this.trackOperation('read', size);
-        
+
         return {
           path,
           operation: 'read' as const,
           success: true,
           duration,
           size,
-          data
+          data,
         };
       } catch (error) {
         this.metrics.errors++;
         this.logger.error('Failed to read file', { path, error });
-        
+
         return {
           path,
           operation: 'read' as const,
           success: false,
           duration: Date.now() - start,
-          error: error as Error
+          error: error as Error,
         };
       }
     });
   }
-  
+
   async writeJSON(path: string, data: any, pretty = true): Promise<FileOperationResult> {
-    const jsonString = pretty 
-      ? JSON.stringify(data, null, 2)
-      : JSON.stringify(data);
-    
+    const jsonString = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+
     return this.writeFile(path, jsonString);
   }
-  
+
   async readJSON(path: string): Promise<FileOperationResult & { data?: any }> {
     const result = await this.readFile(path);
-    
+
     if (result.success && result.data) {
       try {
         const parsed = JSON.parse(result.data);
@@ -146,121 +142,118 @@ export class AsyncFileManager {
         return {
           ...result,
           success: false,
-          error: new Error('Invalid JSON format')
+          error: new Error('Invalid JSON format'),
         };
       }
     }
-    
+
     return result;
   }
-  
+
   async deleteFile(path: string): Promise<FileOperationResult> {
     const start = Date.now();
-    
+
     return this.writeQueue.add(async () => {
       try {
         await fs.unlink(path);
-        
+
         this.trackOperation('delete', 0);
-        
+
         return {
           path,
           operation: 'delete',
           success: true,
-          duration: Date.now() - start
+          duration: Date.now() - start,
         };
       } catch (error) {
         this.metrics.errors++;
         this.logger.error('Failed to delete file', { path, error });
-        
+
         return {
           path,
           operation: 'delete',
           success: false,
           duration: Date.now() - start,
-          error: error as Error
+          error: error as Error,
         };
       }
     });
   }
-  
+
   async ensureDirectory(path: string): Promise<FileOperationResult> {
     const start = Date.now();
-    
+
     try {
       await fs.mkdir(path, { recursive: true });
-      
+
       this.trackOperation('mkdir', 0);
-      
+
       return {
         path,
         operation: 'mkdir',
         success: true,
-        duration: Date.now() - start
+        duration: Date.now() - start,
       };
     } catch (error) {
       this.metrics.errors++;
       this.logger.error('Failed to create directory', { path, error });
-      
+
       return {
         path,
         operation: 'mkdir',
         success: false,
         duration: Date.now() - start,
-        error: error as Error
+        error: error as Error,
       };
     }
   }
-  
+
   async ensureDirectories(paths: string[]): Promise<FileOperationResult[]> {
-    return Promise.all(paths.map(path => this.ensureDirectory(path)));
+    return Promise.all(paths.map((path) => this.ensureDirectory(path)));
   }
-  
+
   private async streamWrite(path: string, data: string | Buffer): Promise<void> {
     const stream = createWriteStream(path);
-    await pipeline(
-      Readable.from(data),
-      stream
-    );
+    await pipeline(Readable.from(data), stream);
   }
-  
+
   async streamRead(path: string): Promise<NodeJS.ReadableStream> {
     return createReadStream(path);
   }
-  
+
   async copyFile(source: string, destination: string): Promise<FileOperationResult> {
     const start = Date.now();
-    
+
     return this.writeQueue.add(async () => {
       try {
         await this.ensureDirectory(dirname(destination));
         await fs.copyFile(source, destination);
-        
+
         const stats = await fs.stat(destination);
         this.trackOperation('write', stats.size);
-        
+
         return {
           path: destination,
           operation: 'write',
           success: true,
           duration: Date.now() - start,
-          size: stats.size
+          size: stats.size,
         };
       } catch (error) {
         this.metrics.errors++;
         this.logger.error('Failed to copy file', { source, destination, error });
-        
+
         return {
           path: destination,
           operation: 'write',
           success: false,
           duration: Date.now() - start,
-          error: error as Error
+          error: error as Error,
         };
       }
     });
   }
-  
+
   async moveFile(source: string, destination: string): Promise<FileOperationResult> {
     const copyResult = await this.copyFile(source, destination);
     if (copyResult.success) {
@@ -268,13 +261,13 @@ export class AsyncFileManager {
     }
     return copyResult;
   }
-  
+
   private trackOperation(type: string, bytes: number): void {
     const count = this.metrics.operations.get(type) || 0;
     this.metrics.operations.set(type, count + 1);
     this.metrics.totalBytes += bytes;
   }
-  
+
   getMetrics() {
     return {
       operations: Object.fromEntries(this.metrics.operations),
@@ -283,19 +276,16 @@ export class AsyncFileManager {
       writeQueueSize: this.writeQueue.size,
       readQueueSize: this.readQueue.size,
       writeQueuePending: this.writeQueue.pending,
-      readQueuePending: this.readQueue.pending
+      readQueuePending: this.readQueue.pending,
     };
   }
-  
+
   async waitForPendingOperations(): Promise<void> {
-    await Promise.all([
-      this.writeQueue.onIdle(),
-      this.readQueue.onIdle()
-    ]);
+    await Promise.all([this.writeQueue.onIdle(), this.readQueue.onIdle()]);
   }
-  
+
   clearQueues(): void {
     this.writeQueue.clear();
     this.readQueue.clear();
   }
-}
+}

package/src/swarm/optimizations/circular-buffer.ts

@@ -8,49 +8,49 @@ export class CircularBuffer<T> {
   private writeIndex = 0;
   private size = 0;
   private totalItemsWritten = 0;
-  
+
   constructor(private capacity: number) {
     if (capacity <= 0) {
       throw new Error('Capacity must be greater than 0');
     }
     this.buffer = new Array(capacity);
   }
-  
+
   push(item: T): void {
     this.buffer[this.writeIndex] = item;
     this.writeIndex = (this.writeIndex + 1) % this.capacity;
     this.size = Math.min(this.size + 1, this.capacity);
     this.totalItemsWritten++;
   }
-  
+
   pushMany(items: T[]): void {
     for (const item of items) {
       this.push(item);
     }
   }
-  
+
   get(index: number): T | undefined {
     if (index < 0 || index >= this.size) {
       return undefined;
     }
-    
+
     // Calculate actual buffer index based on current state
-    const actualIndex = this.size < this.capacity
-      ? index
-      : (this.writeIndex + index) % this.capacity;
-    
+    const actualIndex =
+      this.size < this.capacity ? index : (this.writeIndex + index) % this.capacity;
+
     return this.buffer[actualIndex];
   }
-  
+
   getRecent(count: number): T[] {
     const result: T[] = [];
     const itemsToReturn = Math.min(count, this.size);
-    
+
     // Calculate starting position for most recent items
-    const start = this.size < this.capacity
-      ? Math.max(0, this.size - itemsToReturn)
-      : (this.writeIndex - itemsToReturn + this.capacity) % this.capacity;
-    
+    const start =
+      this.size < this.capacity
+        ? Math.max(0, this.size - itemsToReturn)
+        : (this.writeIndex - itemsToReturn + this.capacity) % this.capacity;
+
     for (let i = 0; i < itemsToReturn; i++) {
       const index = (start + i) % this.capacity;
       const item = this.buffer[index];
@@ -58,13 +58,13 @@ export class CircularBuffer<T> {
         result.push(item);
       }
     }
-    
+
     return result;
   }
-  
+
   getAll(): T[] {
     const result: T[] = [];
-    
+
     if (this.size < this.capacity) {
       // Buffer not full yet, return items in order
       for (let i = 0; i < this.size; i++) {
@@ -83,60 +83,60 @@ export class CircularBuffer<T> {
         }
       }
     }
-    
+
     return result;
   }
-  
+
   find(predicate: (item: T) => boolean): T | undefined {
     const all = this.getAll();
     return all.find(predicate);
   }
-  
+
   filter(predicate: (item: T) => boolean): T[] {
     const all = this.getAll();
     return all.filter(predicate);
   }
-  
+
   clear(): void {
     this.buffer = new Array(this.capacity);
     this.writeIndex = 0;
     this.size = 0;
   }
-  
+
   isEmpty(): boolean {
     return this.size === 0;
   }
-  
+
   isFull(): boolean {
     return this.size === this.capacity;
   }
-  
+
   getSize(): number {
     return this.size;
   }
-  
+
   getCapacity(): number {
     return this.capacity;
   }
-  
+
   getTotalItemsWritten(): number {
     return this.totalItemsWritten;
   }
-  
+
   getOverwrittenCount(): number {
     return Math.max(0, this.totalItemsWritten - this.capacity);
   }
-  
+
   /**
    * Get estimated memory usage of the buffer
    */
   getMemoryUsage(): number {
     if (this.size === 0) return 0;
-    
+
     // Sample first item to estimate size
     const sample = this.buffer[0];
     if (sample === undefined) return 0;
-    
+
     try {
       // Rough estimation based on JSON serialization
       const sampleSize = JSON.stringify(sample).length * 2; // 2 bytes per character
@@ -146,7 +146,7 @@ export class CircularBuffer<T> {
       return this.size * 1024; // 1KB per item default
     }
   }
-  
+
   /**
    * Create a snapshot of the current buffer state
    */
@@ -164,10 +164,10 @@ export class CircularBuffer<T> {
       size: this.size,
       totalItemsWritten: this.totalItemsWritten,
       overwrittenCount: this.getOverwrittenCount(),
-      memoryUsage: this.getMemoryUsage()
+      memoryUsage: this.getMemoryUsage(),
     };
   }
-  
+
   /**
    * Resize the buffer (creates a new buffer with the new capacity)
    */
@@ -175,15 +175,15 @@ export class CircularBuffer<T> {
     if (newCapacity <= 0) {
       throw new Error('New capacity must be greater than 0');
     }
-    
+
     const items = this.getAll();
     this.capacity = newCapacity;
     this.buffer = new Array(newCapacity);
     this.writeIndex = 0;
     this.size = 0;
-    
+
     // Re-add items (newest items will be kept if newCapacity < items.length)
     const itemsToKeep = items.slice(-newCapacity);
     this.pushMany(itemsToKeep);
   }
-}
+}