claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/swarm/optimizations/__tests__/optimization.test.js

@@ -1,348 +0,0 @@
-/**
- * Tests for Swarm Optimizations
- */ // Tests will skip ClaudeAPI-dependent tests for now
-import { describe, it, expect, beforeEach, afterEach, jest } from "@jest/globals";
-import { CircularBuffer } from "../circular-buffer.js";
-import { TTLMap } from "../ttl-map.js";
-import { ClaudeConnectionPool } from "../connection-pool.js";
-import { AsyncFileManager } from "../async-file-manager.js";
-import { OptimizedExecutor } from "../optimized-executor.js";
-import { generateId } from "../../../utils/helpers.js";
-describe('Swarm Optimizations', ()=>{
-    describe('CircularBuffer', ()=>{
-        it('should maintain fixed size', ()=>{
-            const buffer = new CircularBuffer(5);
-            // Add more items than capacity
-            for(let i = 0; i < 10; i++){
-                buffer.push(i);
-            }
-            expect(buffer.getSize()).toBe(5);
-            expect(buffer.getAll()).toEqual([
-                5,
-                6,
-                7,
-                8,
-                9
-            ]);
-        });
-        it('should return recent items correctly', ()=>{
-            const buffer = new CircularBuffer(3);
-            buffer.push('a');
-            buffer.push('b');
-            buffer.push('c');
-            buffer.push('d');
-            expect(buffer.getRecent(2)).toEqual([
-                'c',
-                'd'
-            ]);
-            expect(buffer.getRecent(5)).toEqual([
-                'b',
-                'c',
-                'd'
-            ]); // Only 3 items available
-        });
-        it('should track overwritten count', ()=>{
-            const buffer = new CircularBuffer(3);
-            for(let i = 0; i < 5; i++){
-                buffer.push(i);
-            }
-            expect(buffer.getTotalItemsWritten()).toBe(5);
-            expect(buffer.getOverwrittenCount()).toBe(2);
-        });
-    });
-    describe('TTLMap', ()=>{
-        beforeEach(()=>{
-            jest.useFakeTimers();
-        });
-        afterEach(()=>{
-            jest.useRealTimers();
-        });
-        it('should expire items after TTL', ()=>{
-            const map = new TTLMap({
-                defaultTTL: 1000
-            });
-            map.set('key1', 'value1');
-            expect(map.get('key1')).toBe('value1');
-            // Advance time past TTL
-            jest.advanceTimersByTime(1100);
-            expect(map.get('key1')).toBeUndefined();
-            expect(map.size).toBe(0);
-        });
-        it('should respect max size with LRU eviction', ()=>{
-            const map = new TTLMap({
-                maxSize: 3
-            });
-            map.set('a', 1);
-            jest.advanceTimersByTime(1);
-            map.set('b', 2);
-            jest.advanceTimersByTime(1);
-            map.set('c', 3);
-            // Advance time and access 'a' to make it recently used
-            jest.advanceTimersByTime(1);
-            map.get('a');
-            // Add new item, should evict 'b' (least recently used)
-            jest.advanceTimersByTime(1);
-            map.set('d', 4);
-            expect(map.has('a')).toBe(true);
-            expect(map.has('b')).toBe(false);
-            expect(map.has('c')).toBe(true);
-            expect(map.has('d')).toBe(true);
-        });
-        it('should update TTL on touch', ()=>{
-            const map = new TTLMap({
-                defaultTTL: 1000
-            });
-            map.set('key1', 'value1');
-            // Advance time but not past TTL
-            jest.advanceTimersByTime(800);
-            // Touch to reset TTL
-            map.touch('key1', 2000);
-            // Advance past original TTL
-            jest.advanceTimersByTime(300);
-            // Should still exist due to touch
-            expect(map.get('key1')).toBe('value1');
-            // Advance past new TTL
-            jest.advanceTimersByTime(1800);
-            expect(map.get('key1')).toBeUndefined();
-        });
-    });
-    describe('AsyncFileManager', ()=>{
-        const testDir = '/tmp/swarm-test';
-        let fileManager;
-        beforeEach(()=>{
-            fileManager = new AsyncFileManager();
-        });
-        it('should handle concurrent write operations', async ()=>{
-            // Mock file operations since real file system isn't needed
-            jest.spyOn(fileManager, 'writeFile').mockResolvedValue({
-                success: true,
-                path: 'test-path'
-            });
-            const writes = [];
-            // Queue multiple writes
-            for(let i = 0; i < 5; i++){
-                writes.push(fileManager.writeFile(`${testDir}/test-${i}.txt`, `Content ${i}`));
-            }
-            const results = await Promise.all(writes);
-            expect(results).toHaveLength(5);
-            expect(results.every((r)=>r.success)).toBe(true);
-        });
-        it('should write and read JSON files', async ()=>{
-            const testData = {
-                id: 1,
-                name: 'test',
-                values: [
-                    1,
-                    2,
-                    3
-                ]
-            };
-            const path = `${testDir}/test.json`;
-            const writeResult = await fileManager.writeJSON(path, testData);
-            expect(writeResult.success).toBe(true);
-            const readResult = await fileManager.readJSON(path);
-            expect(readResult.success).toBe(true);
-            expect(readResult.data).toEqual(testData);
-        });
-    });
-    describe('ClaudeConnectionPool', ()=>{
-        let pool;
-        beforeEach(()=>{
-            pool = new ClaudeConnectionPool({
-                min: 2,
-                max: 5
-            });
-        });
-        afterEach(async ()=>{
-            await pool.drain();
-        });
-        it('should reuse connections', async ()=>{
-            // Mock connection behavior since ClaudeAPI isn't available
-            const mockConnection = {
-                id: 'mock-conn-1',
-                isHealthy: true
-            };
-            jest.spyOn(pool, 'acquire').mockResolvedValue(mockConnection);
-            jest.spyOn(pool, 'release').mockResolvedValue(undefined);
-            const conn1 = await pool.acquire();
-            const id1 = conn1.id;
-            await pool.release(conn1);
-            const conn2 = await pool.acquire();
-            const id2 = conn2.id;
-            expect(id2).toBe(id1); // Same connection reused
-            await pool.release(conn2);
-        });
-        it('should create new connections up to max', async ()=>{
-            const connections = [];
-            // Acquire max connections
-            for(let i = 0; i < 5; i++){
-                connections.push(await pool.acquire());
-            }
-            const stats = pool.getStats();
-            expect(stats.total).toBe(5);
-            expect(stats.inUse).toBe(5);
-            // Release all
-            for (const conn of connections){
-                await pool.release(conn);
-            }
-        });
-        it('should execute with automatic acquire/release', async ()=>{
-            let executionCount = 0;
-            const result = await pool.execute(async (api)=>{
-                executionCount++;
-                return 'test-result';
-            });
-            expect(result).toBe('test-result');
-            expect(executionCount).toBe(1);
-            const stats = pool.getStats();
-            expect(stats.inUse).toBe(0); // Connection released
-        });
-    });
-    describe('OptimizedExecutor', ()=>{
-        let executor;
-        beforeEach(()=>{
-            executor = new OptimizedExecutor({
-                connectionPool: {
-                    min: 1,
-                    max: 2
-                },
-                concurrency: 2,
-                caching: {
-                    enabled: true,
-                    ttl: 60000
-                }
-            });
-        });
-        afterEach(async ()=>{
-            await executor.shutdown();
-        });
-        it('should execute tasks successfully', async ()=>{
-            const task = {
-                id: generateId('task'),
-                parentId: generateId('swarm'),
-                type: 'analysis',
-                objective: 'Test task',
-                status: 'pending',
-                priority: 'normal',
-                assignedTo: undefined,
-                dependencies: [],
-                result: undefined,
-                error: undefined,
-                createdAt: new Date(),
-                updatedAt: new Date(),
-                startedAt: undefined,
-                completedAt: undefined,
-                constraints: {
-                    timeout: 30000,
-                    maxRetries: 3,
-                    requiresApproval: false
-                },
-                metadata: {},
-                context: undefined,
-                statusHistory: [],
-                attempts: []
-            };
-            const agentId = {
-                id: generateId('agent'),
-                type: 'executor'
-            };
-            // Mock the API call since ClaudeAPI isn't available
-            const mockResult = {
-                taskId: task.id,
-                agentId: agentId.id,
-                success: true
-            };
-            jest.spyOn(executor, 'executeTask').mockResolvedValue(mockResult);
-            const result = await executor.executeTask(task, agentId);
-            // In real tests, this would check actual results
-            expect(result).toBeDefined();
-            expect(result.taskId).toBe(task.id);
-            expect(result.agentId).toBe(agentId.id);
-        });
-        it('should cache results when enabled', async ()=>{
-            const task = {
-                id: generateId('task'),
-                parentId: generateId('swarm'),
-                type: 'query',
-                objective: 'Cached task',
-                status: 'pending',
-                priority: 'normal',
-                assignedTo: undefined,
-                dependencies: [],
-                result: undefined,
-                error: undefined,
-                createdAt: new Date(),
-                updatedAt: new Date(),
-                startedAt: undefined,
-                completedAt: undefined,
-                constraints: {
-                    timeout: 30000,
-                    maxRetries: 3,
-                    requiresApproval: false,
-                    maxTokens: 4096
-                },
-                metadata: {},
-                context: undefined,
-                statusHistory: [],
-                attempts: []
-            };
-            const agentId = {
-                id: generateId('agent'),
-                type: 'analyst'
-            };
-            // First execution
-            const result1 = await executor.executeTask(task, agentId);
-            // Second execution should hit cache
-            const result2 = await executor.executeTask(task, agentId);
-            const metrics = executor.getMetrics();
-            expect(metrics.cacheHitRate).toBeGreaterThan(0);
-        });
-        it('should track metrics correctly', async ()=>{
-            const initialMetrics = executor.getMetrics();
-            expect(initialMetrics.totalExecuted).toBe(0);
-            // Execute a task to update metrics
-            const task = {
-                id: generateId('task'),
-                parentId: generateId('swarm'),
-                type: 'analysis',
-                objective: 'Test metrics task',
-                status: 'pending',
-                priority: 'normal',
-                assignedTo: undefined,
-                dependencies: [],
-                result: undefined,
-                error: undefined,
-                createdAt: new Date(),
-                updatedAt: new Date(),
-                startedAt: undefined,
-                completedAt: undefined,
-                constraints: {
-                    timeout: 30000,
-                    maxRetries: 3,
-                    requiresApproval: false,
-                    maxTokens: 4096
-                },
-                metadata: {},
-                context: undefined,
-                statusHistory: [],
-                attempts: []
-            };
-            const agentId = {
-                id: generateId('agent'),
-                type: 'executor'
-            };
-            // Mock the execution to return a result
-            const mockResult = {
-                taskId: task.id,
-                agentId: agentId.id,
-                success: true
-            };
-            jest.spyOn(executor, 'executeTask').mockResolvedValue(mockResult);
-            await executor.executeTask(task, agentId);
-            const updatedMetrics = executor.getMetrics();
-            // Check that metrics object exists and has expected structure
-            expect(updatedMetrics).toBeDefined();
-            expect(typeof updatedMetrics.totalExecuted).toBe('number');
-        });
-    });
-});

package/dist/src/swarm/optimizations/async-file-manager.js

@@ -1,285 +0,0 @@
-/**
- * Async File Manager
- * Handles non-blocking file operations with queuing
- */ function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { promises as fs } from "node:fs";
-import { pipeline } from "node:stream/promises";
-import { createWriteStream, createReadStream } from "node:fs";
-import { Readable } from "node:stream";
-import { dirname } from "node:path";
-import PQueue from "p-queue";
-import { Logger } from "../../core/logger.js";
-export class AsyncFileManager {
-    async writeFile(path, data) {
-        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
-                    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',
-                    success: true,
-                    duration,
-                    size
-                };
-            } catch (error) {
-                this.metrics.errors++;
-                this.logger.error('Failed to write file', {
-                    path,
-                    error
-                });
-                return {
-                    path,
-                    operation: 'write',
-                    success: false,
-                    duration: Date.now() - start,
-                    error: error
-                };
-            }
-        });
-    }
-    async readFile(path) {
-        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',
-                    success: true,
-                    duration,
-                    size,
-                    data
-                };
-            } catch (error) {
-                this.metrics.errors++;
-                this.logger.error('Failed to read file', {
-                    path,
-                    error
-                });
-                return {
-                    path,
-                    operation: 'read',
-                    success: false,
-                    duration: Date.now() - start,
-                    error: error
-                };
-            }
-        });
-    }
-    async writeJSON(path, data, pretty = true) {
-        const jsonString = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
-        return this.writeFile(path, jsonString);
-    }
-    async readJSON(path) {
-        const result = await this.readFile(path);
-        if (result.success && result.data) {
-            try {
-                const parsed = JSON.parse(result.data);
-                return {
-                    ...result,
-                    data: parsed
-                };
-            } catch (error) {
-                return {
-                    ...result,
-                    success: false,
-                    error: new Error('Invalid JSON format')
-                };
-            }
-        }
-        return result;
-    }
-    async deleteFile(path) {
-        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
-                };
-            } 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
-                };
-            }
-        });
-    }
-    async ensureDirectory(path) {
-        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
-            };
-        } 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
-            };
-        }
-    }
-    async ensureDirectories(paths) {
-        return Promise.all(paths.map((path)=>this.ensureDirectory(path)));
-    }
-    async streamWrite(path, data) {
-        const stream = createWriteStream(path);
-        await pipeline(Readable.from(data), stream);
-    }
-    async streamRead(path) {
-        return createReadStream(path);
-    }
-    async copyFile(source, destination) {
-        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
-                };
-            } 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
-                };
-            }
-        });
-    }
-    async moveFile(source, destination) {
-        const copyResult = await this.copyFile(source, destination);
-        if (copyResult.success) {
-            await this.deleteFile(source);
-        }
-        return copyResult;
-    }
-    trackOperation(type, bytes) {
-        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),
-            totalBytes: this.metrics.totalBytes,
-            errors: this.metrics.errors,
-            writeQueueSize: this.writeQueue.size,
-            readQueueSize: this.readQueue.size,
-            writeQueuePending: this.writeQueue.pending,
-            readQueuePending: this.readQueue.pending
-        };
-    }
-    async waitForPendingOperations() {
-        await Promise.all([
-            this.writeQueue.onIdle(),
-            this.readQueue.onIdle()
-        ]);
-    }
-    clearQueues() {
-        this.writeQueue.clear();
-        this.readQueue.clear();
-    }
-    constructor(concurrency = {
-        write: 10,
-        read: 20
-    }){
-        _define_property(this, "concurrency", void 0);
-        _define_property(this, "writeQueue", void 0);
-        _define_property(this, "readQueue", void 0);
-        _define_property(this, "logger", void 0);
-        _define_property(this, "metrics", void 0);
-        this.concurrency = concurrency;
-        this.metrics = {
-            operations: new Map(),
-            totalBytes: 0,
-            errors: 0
-        };
-        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',
-            format: 'json',
-            destination: 'console'
-        } : {
-            level: 'info',
-            format: 'json',
-            destination: 'console'
-        };
-        this.logger = new Logger(loggerConfig, {
-            component: 'AsyncFileManager'
-        });
-    }
-}