claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/swarm/claude-code-interface.js

@@ -1,961 +0,0 @@
-/**
- * Claude Code Coordination Interface
- *
- * This module provides the interface layer for coordinating with Claude Code
- * instances, managing agent spawning through the claude CLI, handling process
- * lifecycle, and enabling seamless communication between the swarm system
- * and individual Claude agents.
- */ 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 { spawn } from "node:child_process";
-import { performance } from "node:perf_hooks";
-import * as path from "node:path";
-import { Logger } from "../core/logger.js";
-import { generateId } from "../utils/helpers.js";
-import TaskExecutor from "./executor.js";
-export class ClaudeCodeInterface extends EventEmitter {
-    /**
-   * Initialize the Claude Code interface
-   */ async initialize() {
-        if (this.isInitialized) {
-            this.logger.warn('Claude Code interface already initialized');
-            return;
-        }
-        this.logger.info('Initializing Claude Code interface...');
-        try {
-            // Verify Claude executable exists
-            await this.verifyClaudeExecutable();
-            // Initialize task executor
-            await this.taskExecutor.initialize();
-            // Pre-warm agent pool if configured
-            if (this.config.agentPoolSize > 0) {
-                await this.prewarmAgentPool();
-            }
-            // Start health checks
-            this.startHealthChecks();
-            this.isInitialized = true;
-            this.logger.info('Claude Code interface initialized successfully', {
-                poolSize: this.processPool.idle.length,
-                maxConcurrent: this.config.maxConcurrentAgents
-            });
-            this.emit('initialized');
-        } catch (error) {
-            this.logger.error('Failed to initialize Claude Code interface', error);
-            throw error;
-        }
-    }
-    /**
-   * Shutdown the interface gracefully
-   */ async shutdown() {
-        if (!this.isInitialized) return;
-        this.logger.info('Shutting down Claude Code interface...');
-        try {
-            // Stop health checks
-            if (this.healthCheckInterval) {
-                clearInterval(this.healthCheckInterval);
-            }
-            // Cancel active executions
-            const cancellationPromises = Array.from(this.activeExecutions.keys()).map((executionId)=>this.cancelExecution(executionId, 'Interface shutdown'));
-            await Promise.allSettled(cancellationPromises);
-            // Terminate all agents
-            await this.terminateAllAgents();
-            // Shutdown task executor
-            await this.taskExecutor.shutdown();
-            this.isInitialized = false;
-            this.logger.info('Claude Code interface shut down successfully');
-            this.emit('shutdown');
-        } catch (error) {
-            this.logger.error('Error during Claude Code interface shutdown', error);
-            throw error;
-        }
-    }
-    /**
-   * Spawn a new Claude agent with specified configuration
-   */ async spawnAgent(options) {
-        this.logger.info('Spawning Claude agent', {
-            type: options.type,
-            name: options.name,
-            capabilities: options.capabilities
-        });
-        try {
-            // Check if we can spawn more agents
-            if (this.getTotalActiveAgents() >= this.config.maxConcurrentAgents) {
-                throw new Error('Maximum concurrent agents limit reached');
-            }
-            // Build Claude command
-            const command = this.buildClaudeCommand(options);
-            // Spawn process
-            const process1 = spawn(command.executable, command.args, {
-                cwd: options.workingDirectory || this.config.workingDirectory,
-                env: {
-                    ...process1.env,
-                    ...this.config.environmentVariables,
-                    ...options.environment
-                },
-                stdio: [
-                    'pipe',
-                    'pipe',
-                    'pipe'
-                ],
-                detached: false
-            });
-            if (!process1.pid) {
-                throw new Error('Failed to spawn Claude process');
-            }
-            // Create agent record
-            const agentId = generateId('claude-agent');
-            const agent = {
-                id: agentId,
-                processId: process1.pid,
-                process: process1,
-                type: options.type,
-                capabilities: options.capabilities || [],
-                status: 'initializing',
-                spawnedAt: new Date(),
-                lastActivity: new Date(),
-                totalTasks: 0,
-                totalDuration: 0,
-                metrics: this.initializeAgentMetrics()
-            };
-            this.agents.set(agentId, agent);
-            this.processPool.idle.push(agent);
-            this.processPool.totalSpawned++;
-            // Setup process event handlers
-            this.setupProcessEventHandlers(agent);
-            // Wait for agent to be ready
-            await this.waitForAgentReady(agent);
-            agent.status = 'idle';
-            agent.lastActivity = new Date();
-            this.logger.info('Claude agent spawned successfully', {
-                agentId,
-                processId: process1.pid,
-                type: options.type
-            });
-            this.emit('agent:spawned', {
-                agentId,
-                type: options.type,
-                processId: process1.pid
-            });
-            return agentId;
-        } catch (error) {
-            this.logger.error('Failed to spawn Claude agent', {
-                type: options.type,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            throw error;
-        }
-    }
-    /**
-   * Execute a task using a Claude agent
-   */ async executeTask(taskDefinition, agentId, options = {}) {
-        const executionId = generateId('claude-execution');
-        this.logger.info('Executing task with Claude agent', {
-            executionId,
-            taskId: taskDefinition.id.id,
-            agentId
-        });
-        try {
-            // Get or select agent
-            const agent = agentId ? this.agents.get(agentId) : await this.selectOptimalAgent(taskDefinition);
-            if (!agent) {
-                throw new Error(agentId ? `Agent not found: ${agentId}` : 'No suitable agent available');
-            }
-            if (agent.status !== 'idle') {
-                throw new Error(`Agent ${agent.id} is not available (status: ${agent.status})`);
-            }
-            // Create execution record
-            const execution = {
-                id: executionId,
-                taskId: taskDefinition.id.id,
-                agentId: agent.id,
-                startTime: new Date(),
-                status: 'queued',
-                input: {
-                    task: taskDefinition,
-                    options
-                },
-                retryCount: 0,
-                maxRetries: options.maxRetries || 3
-            };
-            this.activeExecutions.set(executionId, execution);
-            // Update agent status
-            agent.status = 'busy';
-            agent.currentTask = executionId;
-            agent.lastActivity = new Date();
-            // Move agent from idle to busy pool
-            this.moveAgentToBusyPool(agent);
-            // Execute task
-            execution.status = 'running';
-            const result = await this.executeTaskWithAgent(agent, taskDefinition, options);
-            // Update execution record
-            execution.endTime = new Date();
-            execution.duration = execution.endTime.getTime() - execution.startTime.getTime();
-            execution.output = result.result;
-            execution.tokensUsed = result.metadata?.tokensUsed;
-            if (result.success) {
-                execution.status = 'completed';
-                agent.metrics.tasksCompleted++;
-            } else {
-                execution.status = 'failed';
-                execution.error = result.error;
-                agent.metrics.tasksFailed++;
-            }
-            // Update agent metrics
-            this.updateAgentMetrics(agent, execution);
-            // Return agent to idle pool
-            this.returnAgentToIdlePool(agent);
-            this.logger.info('Task execution completed', {
-                executionId,
-                success: result.success,
-                duration: execution.duration,
-                tokensUsed: execution.tokensUsed
-            });
-            this.emit('task:completed', {
-                executionId,
-                taskId: taskDefinition.id.id,
-                agentId: agent.id,
-                success: result.success,
-                duration: execution.duration
-            });
-            return execution;
-        } catch (error) {
-            const execution = this.activeExecutions.get(executionId);
-            if (execution) {
-                execution.status = 'failed';
-                execution.error = error instanceof Error ? error.message : String(error);
-                execution.endTime = new Date();
-                execution.duration = execution.endTime.getTime() - execution.startTime.getTime();
-                // Return agent to pool if it was assigned
-                const agent = this.agents.get(execution.agentId);
-                if (agent) {
-                    this.returnAgentToIdlePool(agent);
-                }
-            }
-            this.logger.error('Task execution failed', {
-                executionId,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            throw error;
-        } finally{
-            this.activeExecutions.delete(executionId);
-        }
-    }
-    /**
-   * Cancel a running task execution
-   */ async cancelExecution(executionId, reason) {
-        const execution = this.activeExecutions.get(executionId);
-        if (!execution) {
-            throw new Error(`Execution not found: ${executionId}`);
-        }
-        this.logger.info('Cancelling task execution', {
-            executionId,
-            reason,
-            taskId: execution.taskId,
-            agentId: execution.agentId
-        });
-        try {
-            execution.status = 'cancelled';
-            execution.error = reason;
-            execution.endTime = new Date();
-            execution.duration = execution.endTime.getTime() - execution.startTime.getTime();
-            // Cancel agent task if running
-            const agent = this.agents.get(execution.agentId);
-            if (agent && agent.currentTask === executionId) {
-                await this.cancelAgentTask(agent);
-                this.returnAgentToIdlePool(agent);
-            }
-            this.emit('task:cancelled', {
-                executionId,
-                reason,
-                taskId: execution.taskId,
-                agentId: execution.agentId
-            });
-        } finally{
-            this.activeExecutions.delete(executionId);
-        }
-    }
-    /**
-   * Terminate a specific agent
-   */ async terminateAgent(agentId, reason = 'Manual termination') {
-        const agent = this.agents.get(agentId);
-        if (!agent) {
-            throw new Error(`Agent not found: ${agentId}`);
-        }
-        this.logger.info('Terminating Claude agent', {
-            agentId,
-            processId: agent.processId,
-            reason
-        });
-        try {
-            // Cancel current task if any
-            if (agent.currentTask) {
-                await this.cancelExecution(agent.currentTask, 'Agent termination');
-            }
-            // Update status
-            agent.status = 'terminated';
-            // Terminate process
-            await this.terminateProcess(agent.process);
-            // Remove from pools and agents map
-            this.removeAgentFromPools(agent);
-            this.agents.delete(agentId);
-            this.processPool.totalTerminated++;
-            this.logger.info('Claude agent terminated successfully', {
-                agentId,
-                reason,
-                totalTasks: agent.totalTasks,
-                totalDuration: agent.totalDuration
-            });
-            this.emit('agent:terminated', {
-                agentId,
-                reason,
-                metrics: agent.metrics
-            });
-        } catch (error) {
-            this.logger.error('Error terminating agent', {
-                agentId,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            throw error;
-        }
-    }
-    /**
-   * Get agent status and metrics
-   */ getAgentStatus(agentId) {
-        return this.agents.get(agentId) || null;
-    }
-    /**
-   * Get all active agents
-   */ getAllAgents() {
-        return Array.from(this.agents.values());
-    }
-    /**
-   * Get execution status
-   */ getExecutionStatus(executionId) {
-        return this.activeExecutions.get(executionId) || null;
-    }
-    /**
-   * Get comprehensive interface metrics
-   */ getInterfaceMetrics() {
-        const agents = Array.from(this.agents.values());
-        const executions = Array.from(this.activeExecutions.values());
-        const totalCompleted = agents.reduce((sum, a)=>sum + a.metrics.tasksCompleted, 0);
-        const totalFailed = agents.reduce((sum, a)=>sum + a.metrics.tasksFailed, 0);
-        const totalTokens = agents.reduce((sum, a)=>sum + a.metrics.totalTokensUsed, 0);
-        const avgResponseTime = agents.length > 0 ? agents.reduce((sum, a)=>sum + a.metrics.averageResponseTime, 0) / agents.length : 0;
-        return {
-            agents: {
-                total: agents.length,
-                idle: this.processPool.idle.length,
-                busy: this.processPool.busy.length,
-                failed: this.processPool.failed.length,
-                terminated: this.processPool.totalTerminated
-            },
-            executions: {
-                active: executions.filter((e)=>e.status === 'running').length,
-                completed: totalCompleted,
-                failed: totalFailed,
-                cancelled: executions.filter((e)=>e.status === 'cancelled').length
-            },
-            performance: {
-                averageResponseTime: avgResponseTime,
-                totalTokensUsed: totalTokens,
-                successRate: totalCompleted + totalFailed > 0 ? totalCompleted / (totalCompleted + totalFailed) : 0,
-                throughput: this.calculateThroughput()
-            },
-            pool: {
-                totalSpawned: this.processPool.totalSpawned,
-                totalTerminated: this.processPool.totalTerminated,
-                recyclingEnabled: this.processPool.recyclingEnabled,
-                poolUtilization: this.calculatePoolUtilization()
-            }
-        };
-    }
-    // Private methods
-    async verifyClaudeExecutable() {
-        try {
-            const { spawn } = await import("node:child_process");
-            const process1 = spawn(this.config.claudeExecutablePath, [
-                '--version'
-            ], {
-                stdio: [
-                    'ignore',
-                    'pipe',
-                    'pipe'
-                ]
-            });
-            return new Promise((resolve, reject)=>{
-                let output = '';
-                process1.stdout?.on('data', (data)=>{
-                    output += data.toString();
-                });
-                process1.on('close', (code)=>{
-                    if (code === 0) {
-                        this.logger.info('Claude executable verified', {
-                            path: this.config.claudeExecutablePath,
-                            version: output.trim()
-                        });
-                        resolve();
-                    } else {
-                        reject(new Error(`Claude executable verification failed with code ${code}`));
-                    }
-                });
-                process1.on('error', reject);
-            });
-        } catch (error) {
-            throw new Error(`Claude executable not found: ${this.config.claudeExecutablePath}`);
-        }
-    }
-    async prewarmAgentPool() {
-        this.logger.info('Pre-warming agent pool', {
-            targetSize: this.config.agentPoolSize
-        });
-        const promises = [];
-        for(let i = 0; i < this.config.agentPoolSize; i++){
-            promises.push(this.spawnAgent({
-                type: 'general',
-                name: `pool-agent-${i}`,
-                capabilities: [
-                    'general'
-                ]
-            }));
-        }
-        const results = await Promise.allSettled(promises);
-        const successful = results.filter((r)=>r.status === 'fulfilled').length;
-        const failed = results.filter((r)=>r.status === 'rejected').length;
-        this.logger.info('Agent pool pre-warming completed', {
-            successful,
-            failed,
-            targetSize: this.config.agentPoolSize
-        });
-    }
-    buildClaudeCommand(options) {
-        const args = [];
-        // Add model
-        args.push('--model', options.model || this.config.defaultModel);
-        // Add max tokens
-        args.push('--max-tokens', String(options.maxTokens || this.config.maxTokens));
-        // Add temperature
-        args.push('--temperature', String(options.temperature || this.config.temperature));
-        // Add system prompt if provided
-        if (options.systemPrompt) {
-            args.push('--system', options.systemPrompt);
-        }
-        // Add tools if specified
-        if (options.tools && options.tools.length > 0) {
-            args.push('--allowedTools', options.tools.join(','));
-        }
-        // Enable streaming if configured
-        if (this.config.enableStreaming) {
-            args.push('--stream');
-        }
-        // Skip permissions for swarm execution
-        args.push('--dangerously-skip-permissions');
-        return {
-            executable: this.config.claudeExecutablePath,
-            args
-        };
-    }
-    setupProcessEventHandlers(agent) {
-        const { process: process1 } = agent;
-        process1.on('exit', (code, signal)=>{
-            this.logger.info('Claude agent process exited', {
-                agentId: agent.id,
-                processId: agent.processId,
-                code,
-                signal
-            });
-            if (agent.status !== 'terminated') {
-                agent.status = 'error';
-                this.moveAgentToFailedPool(agent);
-            }
-            this.emit('agent:exited', {
-                agentId: agent.id,
-                code,
-                signal
-            });
-        });
-        process1.on('error', (error)=>{
-            this.logger.error('Claude agent process error', {
-                agentId: agent.id,
-                processId: agent.processId,
-                error: error.message
-            });
-            agent.status = 'error';
-            this.moveAgentToFailedPool(agent);
-            this.emit('agent:error', {
-                agentId: agent.id,
-                error: error.message
-            });
-        });
-        // Handle stdout/stderr if needed
-        if (this.config.enableLogging) {
-            process1.stdout?.on('data', (data)=>{
-                this.logger.debug('Agent stdout', {
-                    agentId: agent.id,
-                    data: data.toString().trim()
-                });
-            });
-            process1.stderr?.on('data', (data)=>{
-                this.logger.debug('Agent stderr', {
-                    agentId: agent.id,
-                    data: data.toString().trim()
-                });
-            });
-        }
-    }
-    async waitForAgentReady(agent, timeout = 30000) {
-        return new Promise((resolve, reject)=>{
-            const startTime = Date.now();
-            const checkInterval = 1000; // 1 second
-            const checkReady = ()=>{
-                const elapsed = Date.now() - startTime;
-                if (elapsed > timeout) {
-                    reject(new Error(`Agent ${agent.id} failed to become ready within ${timeout}ms`));
-                    return;
-                }
-                // Check if process is still running
-                if (agent.process.killed || agent.process.exitCode !== null) {
-                    reject(new Error(`Agent ${agent.id} process terminated during initialization`));
-                    return;
-                }
-                // For now, assume agent is ready after a short delay
-                // In a real implementation, you might check for specific output or response
-                if (elapsed > 2000) {
-                    // 2 seconds
-                    resolve();
-                } else {
-                    setTimeout(checkReady, checkInterval);
-                }
-            };
-            checkReady();
-        });
-    }
-    async selectOptimalAgent(taskDefinition) {
-        const availableAgents = this.processPool.idle.filter((agent)=>agent.status === 'idle');
-        if (availableAgents.length === 0) {
-            // Try to spawn a new agent if under limit
-            if (this.getTotalActiveAgents() < this.config.maxConcurrentAgents) {
-                const agentId = await this.spawnAgent({
-                    type: 'task-specific',
-                    capabilities: taskDefinition.requirements.capabilities
-                });
-                return this.agents.get(agentId) || null;
-            }
-            return null;
-        }
-        // Select agent based on capabilities and performance
-        const scoredAgents = availableAgents.map((agent)=>({
-                agent,
-                score: this.calculateAgentScore(agent, taskDefinition)
-            }));
-        scoredAgents.sort((a, b)=>b.score - a.score);
-        return scoredAgents[0].agent;
-    }
-    calculateAgentScore(agent, taskDefinition) {
-        let score = 0;
-        // Capability match
-        const requiredCapabilities = taskDefinition.requirements.capabilities;
-        const matchingCapabilities = agent.capabilities.filter((cap)=>requiredCapabilities.includes(cap));
-        score += matchingCapabilities.length / requiredCapabilities.length * 100;
-        // Performance metrics
-        score += agent.metrics.successRate * 50;
-        score += Math.max(0, 50 - agent.metrics.averageResponseTime / 1000) * 10; // Prefer faster agents
-        // Load balancing - prefer agents with fewer completed tasks
-        const maxTasks = Math.max(...this.processPool.idle.map((a)=>a.totalTasks), 1);
-        score += (1 - agent.totalTasks / maxTasks) * 20;
-        return score;
-    }
-    async executeTaskWithAgent(agent, taskDefinition, options) {
-        const startTime = performance.now();
-        try {
-            // Create execution context for the agent
-            const context = {
-                task: taskDefinition,
-                agent: this.convertToAgentState(agent),
-                workingDirectory: options.workingDirectory || this.config.workingDirectory,
-                tempDirectory: path.join(this.config.workingDirectory, 'temp', agent.id),
-                logDirectory: path.join(this.config.workingDirectory, 'logs', agent.id),
-                environment: {
-                    ...this.config.environmentVariables,
-                    CLAUDE_AGENT_ID: agent.id,
-                    CLAUDE_TASK_ID: taskDefinition.id.id
-                },
-                resources: {
-                    maxMemory: taskDefinition.requirements.memoryRequired || 512 * 1024 * 1024,
-                    maxCpuTime: taskDefinition.requirements.maxDuration || 300000,
-                    maxDiskSpace: 1024 * 1024 * 1024,
-                    maxNetworkConnections: 10,
-                    maxFileHandles: 100,
-                    priority: 1
-                }
-            };
-            // Execute using task executor
-            const result = await this.taskExecutor.executeClaudeTask(taskDefinition, context.agent, {
-                model: options.model || this.config.defaultModel,
-                maxTokens: options.maxTokens || this.config.maxTokens,
-                temperature: options.temperature || this.config.temperature,
-                timeout: options.timeout || this.config.timeout,
-                claudePath: this.config.claudeExecutablePath,
-                ...options
-            });
-            const duration = performance.now() - startTime;
-            // Update agent activity
-            agent.lastActivity = new Date();
-            agent.totalTasks++;
-            agent.totalDuration += duration;
-            return result;
-        } catch (error) {
-            const duration = performance.now() - startTime;
-            agent.totalDuration += duration;
-            throw error;
-        }
-    }
-    convertToAgentState(agent) {
-        // Convert ClaudeAgent to AgentState for compatibility
-        return {
-            id: {
-                id: agent.id,
-                swarmId: 'claude-interface',
-                type: agent.type,
-                instance: 1
-            },
-            name: `Claude-${agent.id}`,
-            type: agent.type,
-            status: agent.status,
-            capabilities: this.createAgentCapabilities(agent.capabilities),
-            metrics: {
-                tasksCompleted: agent.metrics.tasksCompleted,
-                tasksFailed: agent.metrics.tasksFailed,
-                averageExecutionTime: agent.metrics.averageResponseTime,
-                successRate: agent.metrics.successRate,
-                cpuUsage: agent.metrics.cpuUsage,
-                memoryUsage: agent.metrics.memoryUsage,
-                diskUsage: 0,
-                networkUsage: 0,
-                codeQuality: 0.8,
-                testCoverage: 0.7,
-                bugRate: 0.1,
-                userSatisfaction: 0.9,
-                totalUptime: Date.now() - agent.spawnedAt.getTime(),
-                lastActivity: agent.lastActivity,
-                responseTime: agent.metrics.averageResponseTime
-            },
-            currentTask: agent.currentTask ? {
-                id: agent.currentTask,
-                swarmId: 'claude-interface',
-                sequence: 0,
-                priority: 1
-            } : undefined,
-            workload: agent.status === 'busy' ? 1 : 0,
-            health: agent.status === 'error' ? 0 : 1,
-            config: {
-                autonomyLevel: 0.8,
-                learningEnabled: false,
-                adaptationEnabled: false,
-                maxTasksPerHour: 60,
-                maxConcurrentTasks: 1,
-                timeoutThreshold: this.config.timeout,
-                reportingInterval: 10000,
-                heartbeatInterval: 5000,
-                permissions: [
-                    'read',
-                    'write',
-                    'execute'
-                ],
-                trustedAgents: [],
-                expertise: {},
-                preferences: {}
-            },
-            environment: {
-                runtime: 'claude',
-                version: '1.0.0',
-                workingDirectory: this.config.workingDirectory,
-                tempDirectory: path.join(this.config.workingDirectory, 'temp', agent.id),
-                logDirectory: path.join(this.config.workingDirectory, 'logs', agent.id),
-                apiEndpoints: {},
-                credentials: {},
-                availableTools: agent.capabilities,
-                toolConfigs: {}
-            },
-            endpoints: [],
-            lastHeartbeat: agent.lastActivity,
-            taskHistory: [],
-            errorHistory: [],
-            parentAgent: undefined,
-            childAgents: [],
-            collaborators: []
-        };
-    }
-    createAgentCapabilities(capabilities) {
-        return {
-            codeGeneration: capabilities.includes('coding') || capabilities.includes('codeGeneration'),
-            codeReview: capabilities.includes('review') || capabilities.includes('codeReview'),
-            testing: capabilities.includes('testing'),
-            documentation: capabilities.includes('documentation'),
-            research: capabilities.includes('research'),
-            analysis: capabilities.includes('analysis'),
-            webSearch: capabilities.includes('webSearch'),
-            apiIntegration: capabilities.includes('apiIntegration'),
-            fileSystem: capabilities.includes('fileSystem'),
-            terminalAccess: capabilities.includes('terminal'),
-            languages: capabilities.filter((c)=>[
-                    'javascript',
-                    'typescript',
-                    'python',
-                    'java'
-                ].includes(c)),
-            frameworks: capabilities.filter((c)=>[
-                    'react',
-                    'node',
-                    'express'
-                ].includes(c)),
-            domains: capabilities.filter((c)=>[
-                    'web',
-                    'api',
-                    'database'
-                ].includes(c)),
-            tools: capabilities.filter((c)=>[
-                    'bash',
-                    'git',
-                    'npm'
-                ].includes(c)),
-            maxConcurrentTasks: 1,
-            maxMemoryUsage: 512 * 1024 * 1024,
-            maxExecutionTime: this.config.timeout,
-            reliability: 0.9,
-            speed: 1.0,
-            quality: 0.8
-        };
-    }
-    async cancelAgentTask(agent) {
-        if (agent.process && !agent.process.killed) {
-            // Send interrupt signal
-            agent.process.kill('SIGINT');
-            // Wait briefly for graceful shutdown
-            await new Promise((resolve)=>setTimeout(resolve, 1000));
-            // Force kill if still running
-            if (!agent.process.killed) {
-                agent.process.kill('SIGKILL');
-            }
-        }
-        agent.currentTask = undefined;
-        agent.status = 'idle';
-        agent.lastActivity = new Date();
-    }
-    async terminateProcess(process1) {
-        if (process1.killed || process1.exitCode !== null) {
-            return;
-        }
-        // Send termination signal
-        process1.kill('SIGTERM');
-        // Wait for graceful shutdown
-        await new Promise((resolve)=>setTimeout(resolve, 2000));
-        // Force kill if still running
-        if (!process1.killed && process1.exitCode === null) {
-            process1.kill('SIGKILL');
-        }
-    }
-    async terminateAllAgents() {
-        const terminationPromises = Array.from(this.agents.keys()).map((agentId)=>this.terminateAgent(agentId, 'Interface shutdown'));
-        await Promise.allSettled(terminationPromises);
-    }
-    moveAgentToBusyPool(agent) {
-        const idleIndex = this.processPool.idle.indexOf(agent);
-        if (idleIndex !== -1) {
-            this.processPool.idle.splice(idleIndex, 1);
-            this.processPool.busy.push(agent);
-        }
-    }
-    returnAgentToIdlePool(agent) {
-        agent.status = 'idle';
-        agent.currentTask = undefined;
-        agent.lastActivity = new Date();
-        const busyIndex = this.processPool.busy.indexOf(agent);
-        if (busyIndex !== -1) {
-            this.processPool.busy.splice(busyIndex, 1);
-            this.processPool.idle.push(agent);
-        }
-    }
-    moveAgentToFailedPool(agent) {
-        // Remove from other pools
-        this.removeAgentFromPools(agent);
-        this.processPool.failed.push(agent);
-    }
-    removeAgentFromPools(agent) {
-        const idleIndex = this.processPool.idle.indexOf(agent);
-        if (idleIndex !== -1) {
-            this.processPool.idle.splice(idleIndex, 1);
-        }
-        const busyIndex = this.processPool.busy.indexOf(agent);
-        if (busyIndex !== -1) {
-            this.processPool.busy.splice(busyIndex, 1);
-        }
-        const failedIndex = this.processPool.failed.indexOf(agent);
-        if (failedIndex !== -1) {
-            this.processPool.failed.splice(failedIndex, 1);
-        }
-    }
-    updateAgentMetrics(agent, execution) {
-        const metrics = agent.metrics;
-        // Update averages
-        const totalTasks = metrics.tasksCompleted + metrics.tasksFailed;
-        if (execution.duration) {
-            metrics.averageResponseTime = totalTasks > 0 ? (metrics.averageResponseTime * (totalTasks - 1) + execution.duration) / totalTasks : execution.duration;
-        }
-        // Update success rate
-        metrics.successRate = totalTasks > 0 ? metrics.tasksCompleted / totalTasks : 0;
-        // Update error rate
-        metrics.errorRate = 1 - metrics.successRate;
-        // Update token usage if available
-        if (execution.tokensUsed) {
-            metrics.totalTokensUsed += execution.tokensUsed;
-        }
-    }
-    getTotalActiveAgents() {
-        return this.processPool.idle.length + this.processPool.busy.length;
-    }
-    calculateThroughput() {
-        const agents = Array.from(this.agents.values());
-        const totalTasks = agents.reduce((sum, a)=>sum + a.totalTasks, 0);
-        const totalTime = agents.reduce((sum, a)=>sum + a.totalDuration, 0);
-        return totalTime > 0 ? totalTasks / totalTime * 60000 : 0; // tasks per minute
-    }
-    calculatePoolUtilization() {
-        const total = this.getTotalActiveAgents();
-        const busy = this.processPool.busy.length;
-        return total > 0 ? busy / total : 0;
-    }
-    startHealthChecks() {
-        this.healthCheckInterval = setInterval(()=>{
-            this.performHealthCheck();
-        }, this.config.healthCheckInterval);
-    }
-    performHealthCheck() {
-        const now = Date.now();
-        for (const agent of this.agents.values()){
-            // Check for stalled agents
-            const inactiveTime = now - agent.lastActivity.getTime();
-            if (agent.status === 'busy' && inactiveTime > this.config.timeout * 2) {
-                this.logger.warn('Agent appears stalled', {
-                    agentId: agent.id,
-                    inactiveTime,
-                    currentTask: agent.currentTask
-                });
-                // Try to recover the agent
-                this.recoverStalledAgent(agent);
-            }
-            // Check for failed processes
-            if (agent.process.killed || agent.process.exitCode !== null) {
-                if (agent.status !== 'terminated') {
-                    this.logger.warn('Agent process died unexpectedly', {
-                        agentId: agent.id,
-                        exitCode: agent.process.exitCode
-                    });
-                    agent.status = 'error';
-                    this.moveAgentToFailedPool(agent);
-                }
-            }
-        }
-    }
-    async recoverStalledAgent(agent) {
-        try {
-            if (agent.currentTask) {
-                await this.cancelExecution(agent.currentTask, 'Agent recovery');
-            }
-            this.returnAgentToIdlePool(agent);
-            this.logger.info('Agent recovered from stalled state', {
-                agentId: agent.id
-            });
-        } catch (error) {
-            this.logger.error('Failed to recover stalled agent', {
-                agentId: agent.id,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            // Terminate the problematic agent
-            await this.terminateAgent(agent.id, 'Recovery failed');
-        }
-    }
-    initializeProcessPool() {
-        return {
-            idle: [],
-            busy: [],
-            failed: [],
-            totalSpawned: 0,
-            totalTerminated: 0,
-            recyclingEnabled: this.config.processRecycling,
-            maxAge: 3600000,
-            maxTasks: 100
-        };
-    }
-    initializeAgentMetrics() {
-        return {
-            tasksCompleted: 0,
-            tasksFailed: 0,
-            averageResponseTime: 0,
-            totalTokensUsed: 0,
-            memoryUsage: 0,
-            cpuUsage: 0,
-            errorRate: 0,
-            successRate: 0
-        };
-    }
-    createDefaultConfig(config) {
-        return {
-            claudeExecutablePath: 'claude',
-            defaultModel: 'sonnet',
-            maxTokens: 4096,
-            temperature: 0.7,
-            timeout: 300000,
-            maxConcurrentAgents: 10,
-            enableStreaming: false,
-            enableLogging: true,
-            workingDirectory: process.cwd(),
-            environmentVariables: {},
-            agentPoolSize: 0,
-            processRecycling: true,
-            healthCheckInterval: 30000,
-            ...config
-        };
-    }
-    setupEventHandlers() {
-        this.on('agent:spawned', (data)=>{
-            this.logger.info('Agent spawned event', data);
-        });
-        this.on('agent:terminated', (data)=>{
-            this.logger.info('Agent terminated event', data);
-        });
-        this.on('task:completed', (data)=>{
-            this.logger.info('Task completed event', data);
-        });
-        this.on('task:cancelled', (data)=>{
-            this.logger.warn('Task cancelled event', data);
-        });
-    }
-    constructor(config = {}, memoryManager){
-        super(), _define_property(this, "logger", void 0), _define_property(this, "config", void 0), _define_property(this, "memoryManager", void 0), _define_property(this, "processPool", void 0), _define_property(this, "activeExecutions", new Map()), _define_property(this, "agents", new Map()), _define_property(this, "taskExecutor", void 0), _define_property(this, "healthCheckInterval", void 0), _define_property(this, "isInitialized", false);
-        this.logger = new Logger('ClaudeCodeInterface');
-        this.config = this.createDefaultConfig(config);
-        this.memoryManager = memoryManager;
-        this.processPool = this.initializeProcessPool();
-        this.taskExecutor = new TaskExecutor({
-            timeoutMs: this.config.timeout,
-            enableMetrics: true,
-            captureOutput: true,
-            streamOutput: this.config.enableStreaming
-        });
-        this.setupEventHandlers();
-    }
-}
-export default ClaudeCodeInterface;