claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/swarm/optimizations/circular-buffer.js

@@ -0,0 +1,162 @@
+/**
+ * Circular Buffer Implementation
+ * Fixed-size buffer that overwrites oldest entries when full
+ */ 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;
+}
+export class CircularBuffer {
+    push(item) {
+        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) {
+        for (const item of items){
+            this.push(item);
+        }
+    }
+    get(index) {
+        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;
+        return this.buffer[actualIndex];
+    }
+    getRecent(count) {
+        const result = [];
+        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;
+        for(let i = 0; i < itemsToReturn; i++){
+            const index = (start + i) % this.capacity;
+            const item = this.buffer[index];
+            if (item !== undefined) {
+                result.push(item);
+            }
+        }
+        return result;
+    }
+    getAll() {
+        const result = [];
+        if (this.size < this.capacity) {
+            // Buffer not full yet, return items in order
+            for(let i = 0; i < this.size; i++){
+                const item = this.buffer[i];
+                if (item !== undefined) {
+                    result.push(item);
+                }
+            }
+        } else {
+            // Buffer is full, start from oldest item
+            for(let i = 0; i < this.capacity; i++){
+                const index = (this.writeIndex + i) % this.capacity;
+                const item = this.buffer[index];
+                if (item !== undefined) {
+                    result.push(item);
+                }
+            }
+        }
+        return result;
+    }
+    find(predicate) {
+        const all = this.getAll();
+        return all.find(predicate);
+    }
+    filter(predicate) {
+        const all = this.getAll();
+        return all.filter(predicate);
+    }
+    clear() {
+        this.buffer = new Array(this.capacity);
+        this.writeIndex = 0;
+        this.size = 0;
+    }
+    isEmpty() {
+        return this.size === 0;
+    }
+    isFull() {
+        return this.size === this.capacity;
+    }
+    getSize() {
+        return this.size;
+    }
+    getCapacity() {
+        return this.capacity;
+    }
+    getTotalItemsWritten() {
+        return this.totalItemsWritten;
+    }
+    getOverwrittenCount() {
+        return Math.max(0, this.totalItemsWritten - this.capacity);
+    }
+    /**
+   * Get estimated memory usage of the buffer
+   */ getMemoryUsage() {
+        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
+            return sampleSize * this.size;
+        } catch  {
+            // If serialization fails, return a default estimate
+            return this.size * 1024; // 1KB per item default
+        }
+    }
+    /**
+   * Create a snapshot of the current buffer state
+   */ snapshot() {
+        return {
+            items: this.getAll(),
+            capacity: this.capacity,
+            size: this.size,
+            totalItemsWritten: this.totalItemsWritten,
+            overwrittenCount: this.getOverwrittenCount(),
+            memoryUsage: this.getMemoryUsage()
+        };
+    }
+    /**
+   * Resize the buffer (creates a new buffer with the new capacity)
+   */ resize(newCapacity) {
+        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);
+    }
+    constructor(capacity){
+        _define_property(this, "capacity", void 0);
+        _define_property(this, "buffer", void 0);
+        _define_property(this, "writeIndex", void 0);
+        _define_property(this, "size", void 0);
+        _define_property(this, "totalItemsWritten", void 0);
+        this.capacity = capacity;
+        this.writeIndex = 0;
+        this.size = 0;
+        this.totalItemsWritten = 0;
+        if (capacity <= 0) {
+            throw new Error('Capacity must be greater than 0');
+        }
+        this.buffer = new Array(capacity);
+    }
+}

package/dist/src/swarm/optimizations/connection-pool.js

@@ -0,0 +1,244 @@
+/**
+ * Connection Pool for Claude API
+ * Manages reusable connections to improve performance
+ */ 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 { EventEmitter } from "node:events";
+import { Logger } from "../../core/logger.js";
+// Mock ClaudeAPI for testing when service doesn't exist
+export class ClaudeAPI {
+    async healthCheck() {
+        return this.isHealthy;
+    }
+    async complete(options) {
+        // Mock response for testing
+        return {
+            content: [
+                {
+                    text: `Mock response for: ${options.messages?.[0]?.content || 'test'}`
+                }
+            ],
+            model: options.model || 'sonnet',
+            usage: {
+                input_tokens: 10,
+                output_tokens: 20
+            }
+        };
+    }
+    constructor(){
+        _define_property(this, "id", void 0);
+        _define_property(this, "isHealthy", void 0);
+        this.id = `mock-api-${Date.now()}`;
+        this.isHealthy = true;
+    }
+}
+export class ClaudeConnectionPool extends EventEmitter {
+    async initialize() {
+        // Create minimum connections
+        for(let i = 0; i < this.config.min; i++){
+            await this.createConnection();
+        }
+        // Start eviction timer
+        this.evictionTimer = setInterval(()=>{
+            this.evictIdleConnections();
+        }, this.config.evictionRunIntervalMillis);
+        this.logger.info('Connection pool initialized', {
+            min: this.config.min,
+            max: this.config.max
+        });
+    }
+    async createConnection() {
+        const id = `conn-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+        const api = new ClaudeAPI();
+        const connection = {
+            id,
+            api,
+            inUse: false,
+            createdAt: new Date(),
+            lastUsedAt: new Date(),
+            useCount: 0
+        };
+        this.connections.set(id, connection);
+        this.emit('connection:created', connection);
+        return connection;
+    }
+    async acquire() {
+        if (this.isShuttingDown) {
+            throw new Error('Connection pool is shutting down');
+        }
+        // Try to find an available connection
+        for (const conn of this.connections.values()){
+            if (!conn.inUse) {
+                conn.inUse = true;
+                conn.lastUsedAt = new Date();
+                conn.useCount++;
+                // Test connection if configured
+                if (this.config.testOnBorrow) {
+                    const isHealthy = await this.testConnection(conn);
+                    if (!isHealthy) {
+                        await this.destroyConnection(conn);
+                        continue;
+                    }
+                }
+                this.emit('connection:acquired', conn);
+                return conn;
+            }
+        }
+        // Create new connection if under limit
+        if (this.connections.size < this.config.max) {
+            const conn = await this.createConnection();
+            conn.inUse = true;
+            conn.useCount++;
+            this.emit('connection:acquired', conn);
+            return conn;
+        }
+        // Wait for a connection to become available
+        return new Promise((resolve, reject)=>{
+            const timeout = setTimeout(()=>{
+                const index = this.waitingQueue.findIndex((item)=>item.resolve === resolve);
+                if (index !== -1) {
+                    this.waitingQueue.splice(index, 1);
+                }
+                reject(new Error('Connection acquire timeout'));
+            }, this.config.acquireTimeoutMillis);
+            this.waitingQueue.push({
+                resolve,
+                reject,
+                timeout
+            });
+        });
+    }
+    async release(connection) {
+        const conn = this.connections.get(connection.id);
+        if (!conn) {
+            this.logger.warn('Attempted to release unknown connection', {
+                id: connection.id
+            });
+            return;
+        }
+        conn.inUse = false;
+        conn.lastUsedAt = new Date();
+        this.emit('connection:released', conn);
+        // Check if anyone is waiting for a connection
+        if (this.waitingQueue.length > 0) {
+            const waiter = this.waitingQueue.shift();
+            if (waiter) {
+                clearTimeout(waiter.timeout);
+                conn.inUse = true;
+                conn.useCount++;
+                waiter.resolve(conn);
+            }
+        }
+    }
+    async execute(fn) {
+        const conn = await this.acquire();
+        try {
+            return await fn(conn.api);
+        } finally{
+            await this.release(conn);
+        }
+    }
+    async testConnection(conn) {
+        try {
+            // Simple health check - could be expanded
+            return true;
+        } catch (error) {
+            this.logger.warn('Connection health check failed', {
+                id: conn.id,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            });
+            return false;
+        }
+    }
+    async destroyConnection(conn) {
+        this.connections.delete(conn.id);
+        this.emit('connection:destroyed', conn);
+        // Ensure minimum connections
+        if (this.connections.size < this.config.min && !this.isShuttingDown) {
+            await this.createConnection();
+        }
+    }
+    evictIdleConnections() {
+        const now = Date.now();
+        const idleThreshold = now - this.config.idleTimeoutMillis;
+        for (const conn of this.connections.values()){
+            if (!conn.inUse && conn.lastUsedAt.getTime() < idleThreshold && this.connections.size > this.config.min) {
+                this.destroyConnection(conn);
+            }
+        }
+    }
+    async drain() {
+        this.isShuttingDown = true;
+        // Clear eviction timer
+        if (this.evictionTimer) {
+            clearInterval(this.evictionTimer);
+            this.evictionTimer = undefined;
+        }
+        // Reject all waiting requests
+        for (const waiter of this.waitingQueue){
+            clearTimeout(waiter.timeout);
+            waiter.reject(new Error('Connection pool is draining'));
+        }
+        this.waitingQueue = [];
+        // Wait for all connections to be released
+        const maxWaitTime = 30000; // 30 seconds
+        const startTime = Date.now();
+        while(true){
+            const inUseCount = Array.from(this.connections.values()).filter((conn)=>conn.inUse).length;
+            if (inUseCount === 0) break;
+            if (Date.now() - startTime > maxWaitTime) {
+                this.logger.warn('Timeout waiting for connections to be released', {
+                    inUseCount
+                });
+                break;
+            }
+            await new Promise((resolve)=>setTimeout(resolve, 100));
+        }
+        // Destroy all connections
+        for (const conn of this.connections.values()){
+            await this.destroyConnection(conn);
+        }
+        this.logger.info('Connection pool drained');
+    }
+    getStats() {
+        const connections = Array.from(this.connections.values());
+        return {
+            total: connections.length,
+            inUse: connections.filter((c)=>c.inUse).length,
+            idle: connections.filter((c)=>!c.inUse).length,
+            waitingQueue: this.waitingQueue.length,
+            totalUseCount: connections.reduce((sum, c)=>sum + c.useCount, 0)
+        };
+    }
+    constructor(config = {}){
+        super(), _define_property(this, "connections", new Map()), _define_property(this, "waitingQueue", []), _define_property(this, "config", void 0), _define_property(this, "logger", void 0), _define_property(this, "evictionTimer", void 0), _define_property(this, "isShuttingDown", false);
+        this.config = {
+            min: 2,
+            max: 10,
+            acquireTimeoutMillis: 30000,
+            idleTimeoutMillis: 30000,
+            evictionRunIntervalMillis: 10000,
+            testOnBorrow: true,
+            ...config
+        };
+        this.logger = new Logger({
+            level: 'info',
+            format: 'json',
+            destination: 'console'
+        }, {
+            component: 'ClaudeConnectionPool'
+        });
+        this.initialize();
+    }
+}

package/dist/src/swarm/optimizations/index.js

@@ -0,0 +1,28 @@
+/**
+ * Swarm Optimizations
+ * Export all optimization components
+ */ export { ClaudeConnectionPool } from "./connection-pool.js";
+export { AsyncFileManager } from "./async-file-manager.js";
+export { CircularBuffer } from "./circular-buffer.js";
+export { TTLMap } from "./ttl-map.js";
+export { OptimizedExecutor } from "./optimized-executor.js";
+// Re-export commonly used together
+export const createOptimizedSwarmStack = (config)=>{
+    const connectionPool = new ClaudeConnectionPool(config?.connectionPool);
+    const fileManager = new AsyncFileManager(config?.fileManager);
+    const executor = new OptimizedExecutor({
+        ...config?.executor,
+        connectionPool: config?.connectionPool,
+        fileOperations: config?.fileManager
+    });
+    return {
+        connectionPool,
+        fileManager,
+        executor,
+        shutdown: async ()=>{
+            await executor.shutdown();
+            await fileManager.waitForPendingOperations();
+            await connectionPool.drain();
+        }
+    };
+};