claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/swarm/optimizations/optimized-executor.js

@@ -0,0 +1,320 @@
+/**
+ * Optimized Task Executor
+ * Implements async execution with connection pooling and caching
+ */ 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";
+import { ClaudeConnectionPool } from "./connection-pool.js";
+import { AsyncFileManager } from "./async-file-manager.js";
+import { TTLMap } from "./ttl-map.js";
+import { CircularBuffer } from "./circular-buffer.js";
+import PQueue from "p-queue";
+export class OptimizedExecutor extends EventEmitter {
+    async executeTask(task, agentId) {
+        const startTime = Date.now();
+        const taskKey = this.getTaskCacheKey(task);
+        // Check cache if enabled
+        if (this.config.caching?.enabled) {
+            const cached = this.resultCache.get(taskKey);
+            if (cached) {
+                this.metrics.cacheHits++;
+                this.logger.debug('Cache hit for task', {
+                    taskId: task.id
+                });
+                return cached;
+            }
+            this.metrics.cacheMisses++;
+        }
+        // Add to active executions
+        this.activeExecutions.add(task.id);
+        // Queue the execution
+        const result = await this.executionQueue.add(async ()=>{
+            try {
+                // Execute with connection pool
+                const executionResult = await this.connectionPool.execute(async (api)=>{
+                    const response = await api.complete({
+                        messages: this.buildMessages(task),
+                        model: task.metadata?.model || 'sonnet',
+                        max_tokens: task.constraints.maxTokens || 4096,
+                        temperature: task.metadata?.temperature || 0.7
+                    });
+                    return {
+                        success: true,
+                        output: response.content[0]?.text || '',
+                        usage: {
+                            inputTokens: response.usage?.input_tokens || 0,
+                            outputTokens: response.usage?.output_tokens || 0
+                        }
+                    };
+                });
+                // Save result to file asynchronously
+                if (this.config.fileOperations?.outputDir) {
+                    const outputPath = `${this.config.fileOperations.outputDir}/${task.id}.json`;
+                    await this.fileManager.writeJSON(outputPath, {
+                        taskId: task.id,
+                        agentId: agentId.id,
+                        result: executionResult,
+                        timestamp: new Date()
+                    });
+                }
+                // Create task result
+                const taskResult = {
+                    taskId: task.id,
+                    agentId: agentId.id,
+                    success: executionResult.success,
+                    output: executionResult.output,
+                    error: undefined,
+                    executionTime: Date.now() - startTime,
+                    tokensUsed: executionResult.usage,
+                    timestamp: new Date()
+                };
+                // Cache result if enabled
+                if (this.config.caching?.enabled && executionResult.success) {
+                    this.resultCache.set(taskKey, taskResult);
+                }
+                // Update metrics
+                this.metrics.totalExecuted++;
+                this.metrics.totalSucceeded++;
+                this.metrics.totalExecutionTime += taskResult.executionTime;
+                // Record in history
+                this.executionHistory.push({
+                    taskId: task.id,
+                    duration: taskResult.executionTime,
+                    status: 'success',
+                    timestamp: new Date()
+                });
+                // Check if slow task
+                if (this.config.monitoring?.slowTaskThreshold && taskResult.executionTime > this.config.monitoring.slowTaskThreshold) {
+                    this.logger.warn('Slow task detected', {
+                        taskId: task.id,
+                        duration: taskResult.executionTime,
+                        threshold: this.config.monitoring.slowTaskThreshold
+                    });
+                }
+                this.emit('task:completed', taskResult);
+                return taskResult;
+            } catch (error) {
+                this.metrics.totalExecuted++;
+                this.metrics.totalFailed++;
+                const errorResult = {
+                    taskId: task.id,
+                    agentId: agentId.id,
+                    success: false,
+                    output: '',
+                    error: {
+                        type: error instanceof Error ? error.constructor.name : 'UnknownError',
+                        message: error instanceof Error ? error.message : 'Unknown error',
+                        code: error.code,
+                        stack: error instanceof Error ? error.stack : undefined,
+                        context: {
+                            taskId: task.id,
+                            agentId: agentId.id
+                        },
+                        recoverable: this.isRecoverableError(error),
+                        retryable: this.isRetryableError(error)
+                    },
+                    executionTime: Date.now() - startTime,
+                    timestamp: new Date()
+                };
+                // Record in history
+                this.executionHistory.push({
+                    taskId: task.id,
+                    duration: errorResult.executionTime,
+                    status: 'failed',
+                    timestamp: new Date()
+                });
+                this.emit('task:failed', errorResult);
+                throw error;
+            } finally{
+                this.activeExecutions.delete(task.id);
+            }
+        });
+        return result;
+    }
+    async executeBatch(tasks, agentId) {
+        return Promise.all(tasks.map((task)=>this.executeTask(task, agentId)));
+    }
+    buildMessages(task) {
+        const messages = [];
+        // Add system message if needed
+        if (task.metadata?.systemPrompt) {
+            messages.push({
+                role: 'system',
+                content: task.metadata.systemPrompt
+            });
+        }
+        // Add main task objective
+        messages.push({
+            role: 'user',
+            content: task.objective
+        });
+        // Add context if available
+        if (task.context) {
+            if (task.context.previousResults?.length) {
+                messages.push({
+                    role: 'assistant',
+                    content: 'Previous results:\n' + task.context.previousResults.map((r)=>r.output).join('\n\n')
+                });
+            }
+            if (task.context.relatedTasks?.length) {
+                messages.push({
+                    role: 'user',
+                    content: 'Related context:\n' + task.context.relatedTasks.map((t)=>t.objective).join('\n')
+                });
+            }
+        }
+        return messages;
+    }
+    getTaskCacheKey(task) {
+        // Create a cache key based on task properties
+        return `${task.type}-${task.objective}-${JSON.stringify(task.metadata || {})}`;
+    }
+    isRecoverableError(error) {
+        if (!error) return false;
+        // Network errors are often recoverable
+        if (error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT' || error.code === 'ENOTFOUND') {
+            return true;
+        }
+        // Rate limit errors are recoverable with backoff
+        if (error.status === 429) {
+            return true;
+        }
+        return false;
+    }
+    isRetryableError(error) {
+        if (!error) return false;
+        // Most recoverable errors are retryable
+        if (this.isRecoverableError(error)) {
+            return true;
+        }
+        // Server errors might be temporary
+        if (error.status >= 500 && error.status < 600) {
+            return true;
+        }
+        return false;
+    }
+    getMetrics() {
+        const history = this.executionHistory.getAll();
+        const avgExecutionTime = this.metrics.totalExecuted > 0 ? this.metrics.totalExecutionTime / this.metrics.totalExecuted : 0;
+        const cacheTotal = this.metrics.cacheHits + this.metrics.cacheMisses;
+        const cacheHitRate = cacheTotal > 0 ? this.metrics.cacheHits / cacheTotal : 0;
+        return {
+            totalExecuted: this.metrics.totalExecuted,
+            totalSucceeded: this.metrics.totalSucceeded,
+            totalFailed: this.metrics.totalFailed,
+            avgExecutionTime,
+            cacheHitRate,
+            queueLength: this.executionQueue.size,
+            activeExecutions: this.activeExecutions.size
+        };
+    }
+    emitMetrics() {
+        const metrics = this.getMetrics();
+        this.emit('metrics', metrics);
+        // Also log if configured
+        this.logger.info('Executor metrics', metrics);
+    }
+    async waitForPendingExecutions() {
+        await this.executionQueue.onIdle();
+        await this.fileManager.waitForPendingOperations();
+    }
+    async shutdown() {
+        this.logger.info('Shutting down optimized executor');
+        // Clear the queue
+        this.executionQueue.clear();
+        // Wait for active executions
+        await this.waitForPendingExecutions();
+        // Drain connection pool
+        await this.connectionPool.drain();
+        // Clear caches
+        this.resultCache.destroy();
+        this.logger.info('Optimized executor shut down');
+    }
+    /**
+   * Get execution history for analysis
+   */ getExecutionHistory() {
+        return this.executionHistory.snapshot();
+    }
+    /**
+   * Get connection pool statistics
+   */ getConnectionPoolStats() {
+        return this.connectionPool.getStats();
+    }
+    /**
+   * Get file manager metrics
+   */ getFileManagerMetrics() {
+        return this.fileManager.getMetrics();
+    }
+    /**
+   * Get cache statistics
+   */ getCacheStats() {
+        return this.resultCache.getStats();
+    }
+    constructor(config = {}){
+        super(), _define_property(this, "config", void 0), _define_property(this, "logger", void 0), _define_property(this, "connectionPool", void 0), _define_property(this, "fileManager", void 0), _define_property(this, "executionQueue", void 0), _define_property(this, "resultCache", void 0), _define_property(this, "executionHistory", void 0), _define_property(this, "metrics", void 0), _define_property(this, "activeExecutions", void 0), this.config = config, this.metrics = {
+            totalExecuted: 0,
+            totalSucceeded: 0,
+            totalFailed: 0,
+            totalExecutionTime: 0,
+            cacheHits: 0,
+            cacheMisses: 0
+        }, this.activeExecutions = new Set();
+        // 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: 'OptimizedExecutor'
+        });
+        // Initialize connection pool
+        this.connectionPool = new ClaudeConnectionPool({
+            min: config.connectionPool?.min || 2,
+            max: config.connectionPool?.max || 10
+        });
+        // Initialize file manager
+        this.fileManager = new AsyncFileManager({
+            write: config.fileOperations?.concurrency || 10,
+            read: config.fileOperations?.concurrency || 20
+        });
+        // Initialize execution queue
+        this.executionQueue = new PQueue({
+            concurrency: config.concurrency || 10
+        });
+        // Initialize result cache
+        this.resultCache = new TTLMap({
+            defaultTTL: config.caching?.ttl || 3600000,
+            maxSize: config.caching?.maxSize || 1000,
+            onExpire: (key, value)=>{
+                this.logger.debug('Cache entry expired', {
+                    taskId: key
+                });
+            }
+        });
+        // Initialize execution history
+        this.executionHistory = new CircularBuffer(1000);
+        // Start monitoring if configured
+        if (config.monitoring?.metricsInterval) {
+            setInterval(()=>{
+                this.emitMetrics();
+            }, config.monitoring.metricsInterval);
+        }
+    }
+}

package/dist/src/swarm/optimizations/ttl-map.js

@@ -0,0 +1,234 @@
+/**
+ * TTL Map Implementation
+ * Map with time-to-live for automatic entry expiration
+ */ 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 TTLMap {
+    set(key, value, ttl) {
+        const now = Date.now();
+        const expiry = now + (ttl || this.defaultTTL);
+        // Check if we need to evict items due to size limit
+        if (this.maxSize && this.items.size >= this.maxSize && !this.items.has(key)) {
+            this.evictLRU();
+        }
+        this.items.set(key, {
+            value,
+            expiry,
+            createdAt: now,
+            accessCount: 0,
+            lastAccessedAt: now
+        });
+    }
+    get(key) {
+        const item = this.items.get(key);
+        if (!item) {
+            this.stats.misses++;
+            return undefined;
+        }
+        const now = Date.now();
+        if (now > item.expiry) {
+            this.items.delete(key);
+            this.stats.expirations++;
+            this.stats.misses++;
+            if (this.onExpire) {
+                this.onExpire(key, item.value);
+            }
+            return undefined;
+        }
+        // Update access stats
+        item.accessCount++;
+        item.lastAccessedAt = now;
+        this.stats.hits++;
+        return item.value;
+    }
+    has(key) {
+        const item = this.items.get(key);
+        if (!item) {
+            return false;
+        }
+        if (Date.now() > item.expiry) {
+            this.items.delete(key);
+            this.stats.expirations++;
+            if (this.onExpire) {
+                this.onExpire(key, item.value);
+            }
+            return false;
+        }
+        return true;
+    }
+    delete(key) {
+        return this.items.delete(key);
+    }
+    clear() {
+        this.items.clear();
+    }
+    /**
+   * Update TTL for an existing key
+   */ touch(key, ttl) {
+        const item = this.items.get(key);
+        if (!item || Date.now() > item.expiry) {
+            return false;
+        }
+        item.expiry = Date.now() + (ttl || this.defaultTTL);
+        item.lastAccessedAt = Date.now();
+        return true;
+    }
+    /**
+   * Get remaining TTL for a key
+   */ getTTL(key) {
+        const item = this.items.get(key);
+        if (!item) {
+            return -1;
+        }
+        const remaining = item.expiry - Date.now();
+        return remaining > 0 ? remaining : -1;
+    }
+    /**
+   * Get all keys (excluding expired ones)
+   */ keys() {
+        const now = Date.now();
+        const validKeys = [];
+        for (const [key, item] of this.items){
+            if (now <= item.expiry) {
+                validKeys.push(key);
+            }
+        }
+        return validKeys;
+    }
+    /**
+   * Get all values (excluding expired ones)
+   */ values() {
+        const now = Date.now();
+        const validValues = [];
+        for (const item of this.items.values()){
+            if (now <= item.expiry) {
+                validValues.push(item.value);
+            }
+        }
+        return validValues;
+    }
+    /**
+   * Get all entries (excluding expired ones)
+   */ entries() {
+        const now = Date.now();
+        const validEntries = [];
+        for (const [key, item] of this.items){
+            if (now <= item.expiry) {
+                validEntries.push([
+                    key,
+                    item.value
+                ]);
+            }
+        }
+        return validEntries;
+    }
+    /**
+   * Get size (excluding expired items)
+   */ get size() {
+        this.cleanup(); // Clean up expired items first
+        return this.items.size;
+    }
+    startCleanup() {
+        this.cleanupTimer = setInterval(()=>{
+            this.cleanup();
+        }, this.cleanupInterval);
+    }
+    cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [key, item] of this.items){
+            if (now > item.expiry) {
+                this.items.delete(key);
+                cleaned++;
+                this.stats.expirations++;
+                if (this.onExpire) {
+                    this.onExpire(key, item.value);
+                }
+            }
+        }
+        if (cleaned > 0) {
+        // Optional: Log cleanup stats
+        }
+    }
+    evictLRU() {
+        let lruKey;
+        let lruTime = Infinity;
+        // Find least recently used item
+        for (const [key, item] of this.items){
+            if (item.lastAccessedAt < lruTime) {
+                lruTime = item.lastAccessedAt;
+                lruKey = key;
+            }
+        }
+        if (lruKey !== undefined) {
+            this.items.delete(lruKey);
+            this.stats.evictions++;
+        }
+    }
+    /**
+   * Stop the cleanup timer
+   */ destroy() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+        }
+        this.items.clear();
+    }
+    /**
+   * Get statistics about the map
+   */ getStats() {
+        return {
+            ...this.stats,
+            size: this.items.size,
+            hitRate: this.stats.hits / (this.stats.hits + this.stats.misses) || 0
+        };
+    }
+    /**
+   * Get detailed information about all items
+   */ inspect() {
+        const now = Date.now();
+        const result = new Map();
+        for (const [key, item] of this.items){
+            if (now <= item.expiry) {
+                result.set(key, {
+                    value: item.value,
+                    ttl: item.expiry - now,
+                    age: now - item.createdAt,
+                    accessCount: item.accessCount,
+                    lastAccessed: now - item.lastAccessedAt
+                });
+            }
+        }
+        return result;
+    }
+    constructor(options = {}){
+        _define_property(this, "items", new Map());
+        _define_property(this, "cleanupTimer", void 0);
+        _define_property(this, "defaultTTL", void 0);
+        _define_property(this, "cleanupInterval", void 0);
+        _define_property(this, "maxSize", void 0);
+        _define_property(this, "onExpire", void 0);
+        _define_property(this, "stats", {
+            hits: 0,
+            misses: 0,
+            evictions: 0,
+            expirations: 0
+        });
+        this.defaultTTL = options.defaultTTL || 3600000; // 1 hour default
+        this.cleanupInterval = options.cleanupInterval || 60000; // 1 minute default
+        this.maxSize = options.maxSize;
+        this.onExpire = options.onExpire;
+        this.startCleanup();
+    }
+}