claude-flow-novice 2.0.4 → 2.0.5

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

@@ -1,162 +0,0 @@
-/**
- * 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

@@ -1,244 +0,0 @@
-/**
- * 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

@@ -1,28 +0,0 @@
-/**
- * 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();
-        }
-    };
-};