claude-flow-novice 2.0.3 → 2.0.5

package/dist/src/web/messaging/agent-status-tracker.js

@@ -0,0 +1,453 @@
+/**
+ * Agent Status Tracker - Real-time tracking of agent status and coordination
+ * Optimized for 3-agent swarms with detailed status visualization
+ */ 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 "events";
+export class AgentStatusTracker extends EventEmitter {
+    /**
+   * Update agent status with detailed information
+   */ updateAgentStatus(update) {
+        const { swarmId, ...agentUpdate } = update;
+        const existing = this.agentStatuses.get(update.id) || this.createDefaultAgentStatus(update.id, update.type);
+        const updatedStatus = {
+            ...existing,
+            ...agentUpdate,
+            lastActivity: new Date().toISOString()
+        };
+        // Store status
+        this.agentStatuses.set(update.id, updatedStatus);
+        // Update history
+        this.updateStatusHistory(update.id, updatedStatus);
+        // Update swarm status
+        this.updateSwarmStatus(swarmId);
+        // Emit status change event
+        this.emit('status-change', {
+            swarmId,
+            agentId: update.id,
+            previousStatus: existing.status,
+            currentStatus: updatedStatus.status,
+            updatedStatus
+        });
+        this.logger.debug('Agent status updated', {
+            agentId: update.id,
+            swarmId,
+            status: updatedStatus.status,
+            task: updatedStatus.currentTask?.description
+        });
+    }
+    /**
+   * Update agent task progress
+   */ updateTaskProgress(agentId, swarmId, progress) {
+        const agent = this.agentStatuses.get(agentId);
+        if (!agent) return;
+        agent.currentTask = {
+            id: progress.taskId,
+            description: progress.description,
+            startTime: agent.currentTask?.startTime || new Date().toISOString(),
+            estimatedCompletion: progress.estimatedCompletion,
+            progress: progress.progress
+        };
+        if (progress.reasoning) {
+            agent.reasoning = progress.reasoning;
+        }
+        // Update status based on progress
+        if (progress.progress >= 100) {
+            agent.status = 'completed';
+            agent.performance.tasksCompleted += 1;
+        } else if (progress.progress > 0) {
+            agent.status = 'working';
+        }
+        this.updateAgentStatus({
+            ...agent,
+            swarmId
+        });
+    }
+    /**
+   * Update coordination between agents
+   */ updateCoordination(swarmId, coordination) {
+        const fromAgent = this.agentStatuses.get(coordination.fromAgent);
+        const toAgent = this.agentStatuses.get(coordination.toAgent);
+        if (!fromAgent || !toAgent) return;
+        switch(coordination.action){
+            case 'handoff':
+                fromAgent.coordination.pendingHandoffs -= 1;
+                toAgent.coordination.pendingHandoffs += 1;
+                fromAgent.performance.coordinationEvents += 1;
+                break;
+            case 'request':
+                toAgent.coordination.pendingHandoffs += 1;
+                break;
+            case 'block':
+                fromAgent.coordination.blocking.push(coordination.toAgent);
+                toAgent.coordination.blockedBy.push(coordination.fromAgent);
+                toAgent.status = 'blocked';
+                break;
+            case 'unblock':
+                fromAgent.coordination.blocking = fromAgent.coordination.blocking.filter((id)=>id !== coordination.toAgent);
+                toAgent.coordination.blockedBy = toAgent.coordination.blockedBy.filter((id)=>id !== coordination.fromAgent);
+                if (toAgent.coordination.blockedBy.length === 0) {
+                    toAgent.status = 'active';
+                }
+                break;
+        }
+        // Update both agents
+        this.updateAgentStatus({
+            ...fromAgent,
+            swarmId
+        });
+        this.updateAgentStatus({
+            ...toAgent,
+            swarmId
+        });
+        // Emit coordination event
+        this.emit('coordination-update', {
+            swarmId,
+            coordination,
+            timestamp: new Date().toISOString()
+        });
+    }
+    /**
+   * Get current swarm status with all agent details
+   */ async getSwarmStatus(swarmId) {
+        return this.swarmStatuses.get(swarmId) || null;
+    }
+    /**
+   * Get agent status with history
+   */ getAgentStatus(agentId) {
+        return {
+            current: this.agentStatuses.get(agentId) || null,
+            history: this.statusHistory.get(agentId) || []
+        };
+    }
+    /**
+   * Get real-time dashboard data for 3-agent swarms
+   */ getSwarmDashboard(swarmId) {
+        const swarmStatus = this.swarmStatuses.get(swarmId);
+        if (!swarmStatus) return null;
+        const agents = swarmStatus.agents;
+        const activeAgents = agents.filter((a)=>a.status === 'active' || a.status === 'working');
+        return {
+            swarmId,
+            lastUpdated: new Date().toISOString(),
+            overview: {
+                totalAgents: agents.length,
+                activeAgents: activeAgents.length,
+                completedTasks: swarmStatus.tasks.completed,
+                overallProgress: swarmStatus.tasks.progress,
+                efficiency: swarmStatus.performance.efficiency
+            },
+            agents: agents.map((agent)=>({
+                    id: agent.id,
+                    type: agent.type,
+                    status: agent.status,
+                    currentTask: agent.currentTask,
+                    progress: agent.currentTask?.progress || 0,
+                    reasoning: agent.reasoning,
+                    coordination: {
+                        connectedTo: agent.coordination.connectedAgents,
+                        pendingWork: agent.coordination.pendingHandoffs,
+                        blockers: agent.coordination.blockedBy.length
+                    }
+                })),
+            coordination: {
+                activeHandoffs: swarmStatus.coordination.activeHandoffs,
+                efficiency: swarmStatus.coordination.coordinationEfficiency,
+                bottlenecks: swarmStatus.coordination.bottlenecks,
+                communicationMatrix: this.generateCommunicationMatrix(agents)
+            },
+            alerts: this.generateStatusAlerts(swarmStatus),
+            relaunchInfo: swarmStatus.relaunchHistory ? {
+                count: swarmStatus.relaunchHistory.count,
+                canRelaunch: swarmStatus.relaunchHistory.count < 10,
+                lastAttempt: swarmStatus.relaunchHistory.attempts[swarmStatus.relaunchHistory.attempts.length - 1]
+            } : null
+        };
+    }
+    /**
+   * Generate performance analytics
+   */ getPerformanceAnalytics(swarmId, timeRange = '1h') {
+        const swarmStatus = this.swarmStatuses.get(swarmId);
+        if (!swarmStatus) return null;
+        const agents = swarmStatus.agents;
+        const cutoff = this.parseTimeRange(timeRange);
+        return {
+            swarmId,
+            timeRange,
+            generatedAt: new Date().toISOString(),
+            performance: {
+                overallEfficiency: swarmStatus.performance.efficiency,
+                throughput: swarmStatus.performance.throughput,
+                averageTaskTime: this.calculateAverageTaskTime(agents),
+                coordinationOverhead: this.calculateCoordinationOverhead(agents)
+            },
+            agentPerformance: agents.map((agent)=>({
+                    id: agent.id,
+                    type: agent.type,
+                    tasksCompleted: agent.performance.tasksCompleted,
+                    successRate: agent.performance.successRate,
+                    averageTaskTime: agent.performance.averageTaskTime,
+                    coordinationEvents: agent.performance.coordinationEvents
+                })),
+            trends: {
+                productivityTrend: this.calculateProductivityTrend(agents),
+                coordinationTrend: this.calculateCoordinationTrend(swarmStatus),
+                errorRate: this.calculateErrorRate(agents)
+            },
+            recommendations: this.generatePerformanceRecommendations(swarmStatus)
+        };
+    }
+    /**
+   * Add swarm relaunch to history
+   */ recordSwarmRelaunch(swarmId, reason, changes) {
+        const swarmStatus = this.swarmStatuses.get(swarmId);
+        if (!swarmStatus) return;
+        if (!swarmStatus.relaunchHistory) {
+            swarmStatus.relaunchHistory = {
+                count: 0,
+                attempts: []
+            };
+        }
+        swarmStatus.relaunchHistory.count += 1;
+        swarmStatus.relaunchHistory.attempts.push({
+            timestamp: new Date().toISOString(),
+            reason,
+            changes
+        });
+        this.emit('swarm-relaunch-recorded', {
+            swarmId,
+            relaunchCount: swarmStatus.relaunchHistory.count,
+            reason
+        });
+    }
+    createDefaultAgentStatus(id, type) {
+        return {
+            id,
+            type,
+            status: 'idle',
+            lastActivity: new Date().toISOString(),
+            performance: {
+                tasksCompleted: 0,
+                averageTaskTime: 0,
+                successRate: 1.0,
+                coordinationEvents: 0
+            },
+            coordination: {
+                connectedAgents: [],
+                pendingHandoffs: 0,
+                blockedBy: [],
+                blocking: []
+            },
+            resources: {},
+            reasoning: {}
+        };
+    }
+    updateStatusHistory(agentId, status) {
+        if (!this.statusHistory.has(agentId)) {
+            this.statusHistory.set(agentId, []);
+        }
+        const history = this.statusHistory.get(agentId);
+        history.push({
+            ...status
+        }); // Deep copy
+        // Trim history to max length
+        if (history.length > this.MAX_HISTORY_LENGTH) {
+            history.splice(0, history.length - this.MAX_HISTORY_LENGTH);
+        }
+    }
+    updateSwarmStatus(swarmId) {
+        const agents = Array.from(this.agentStatuses.values());
+        const swarmAgents = agents; // All agents belong to the swarm in this simple case
+        if (swarmAgents.length === 0) return;
+        const existingSwarm = this.swarmStatuses.get(swarmId);
+        // Calculate coordination metrics
+        const coordination = this.calculateCoordinationMetrics(swarmAgents);
+        // Calculate task metrics
+        const tasks = this.calculateTaskMetrics(swarmAgents);
+        // Calculate performance metrics
+        const performance = this.calculatePerformanceMetrics(swarmAgents, existingSwarm);
+        // Determine overall swarm status
+        const overallStatus = this.determineSwarmStatus(swarmAgents);
+        const swarmStatus = {
+            swarmId,
+            status: overallStatus,
+            agents: swarmAgents,
+            coordination,
+            tasks,
+            performance,
+            relaunchHistory: existingSwarm?.relaunchHistory
+        };
+        this.swarmStatuses.set(swarmId, swarmStatus);
+    }
+    calculateCoordinationMetrics(agents) {
+        const totalHandoffs = agents.reduce((sum, agent)=>sum + agent.coordination.pendingHandoffs, 0);
+        const totalEvents = agents.reduce((sum, agent)=>sum + agent.performance.coordinationEvents, 0);
+        // Calculate communication patterns
+        const communicationPatterns = {};
+        for (const agent of agents){
+            for (const connectedAgent of agent.coordination.connectedAgents){
+                const key = `${agent.id}-${connectedAgent}`;
+                communicationPatterns[key] = (communicationPatterns[key] || 0) + 1;
+            }
+        }
+        // Identify bottlenecks
+        const bottlenecks = [];
+        for (const agent of agents){
+            if (agent.coordination.blockedBy.length > 0) {
+                bottlenecks.push(`${agent.id} blocked by ${agent.coordination.blockedBy.join(', ')}`);
+            }
+            if (agent.coordination.pendingHandoffs > 2) {
+                bottlenecks.push(`${agent.id} has high handoff queue (${agent.coordination.pendingHandoffs})`);
+            }
+        }
+        return {
+            activeHandoffs: totalHandoffs,
+            coordinationEfficiency: totalEvents > 0 ? Math.min(100, totalEvents / agents.length * 10) : 100,
+            communicationPatterns,
+            bottlenecks
+        };
+    }
+    calculateTaskMetrics(agents) {
+        const total = agents.reduce((sum, agent)=>sum + agent.performance.tasksCompleted, 0);
+        const active = agents.filter((agent)=>agent.currentTask && agent.status === 'working').length;
+        const completed = agents.filter((agent)=>agent.status === 'completed').length;
+        const failed = agents.filter((agent)=>agent.status === 'error').length;
+        const progress = agents.length > 0 ? agents.reduce((sum, agent)=>sum + (agent.currentTask?.progress || 0), 0) / agents.length : 0;
+        return {
+            total,
+            active,
+            completed,
+            failed,
+            progress
+        };
+    }
+    calculatePerformanceMetrics(agents, existingSwarm) {
+        const completedTasks = agents.reduce((sum, agent)=>sum + agent.performance.tasksCompleted, 0);
+        const averageTaskTime = agents.length > 0 ? agents.reduce((sum, agent)=>sum + agent.performance.averageTaskTime, 0) / agents.length : 0;
+        const efficiency = agents.length > 0 ? agents.reduce((sum, agent)=>sum + agent.performance.successRate, 0) / agents.length * 100 : 0;
+        return {
+            startTime: existingSwarm?.performance.startTime || new Date().toISOString(),
+            efficiency,
+            throughput: completedTasks / Math.max(1, averageTaskTime / 3600)
+        };
+    }
+    determineSwarmStatus(agents) {
+        if (agents.length === 0) return 'initializing';
+        const errorAgents = agents.filter((a)=>a.status === 'error');
+        if (errorAgents.length > 0) return 'error';
+        const completedAgents = agents.filter((a)=>a.status === 'completed');
+        if (completedAgents.length === agents.length) return 'completed';
+        const workingAgents = agents.filter((a)=>a.status === 'working' || a.status === 'coordinating');
+        if (workingAgents.length > 0) return 'active';
+        return 'active';
+    }
+    generateCommunicationMatrix(agents) {
+        const matrix = {};
+        for (const agent of agents){
+            matrix[agent.id] = {};
+            for (const otherAgent of agents){
+                if (agent.id !== otherAgent.id) {
+                    matrix[agent.id][otherAgent.id] = agent.coordination.connectedAgents.includes(otherAgent.id) ? 1 : 0;
+                }
+            }
+        }
+        return matrix;
+    }
+    generateStatusAlerts(swarmStatus) {
+        const alerts = [];
+        // Check for blocked agents
+        const blockedAgents = swarmStatus.agents.filter((a)=>a.status === 'blocked');
+        if (blockedAgents.length > 0) {
+            alerts.push(`${blockedAgents.length} agent(s) blocked`);
+        }
+        // Check for coordination bottlenecks
+        if (swarmStatus.coordination.activeHandoffs > 5) {
+            alerts.push(`High coordination load (${swarmStatus.coordination.activeHandoffs} pending handoffs)`);
+        }
+        // Check efficiency
+        if (swarmStatus.performance.efficiency < 50) {
+            alerts.push('Low swarm efficiency detected');
+        }
+        // Check for error agents
+        const errorAgents = swarmStatus.agents.filter((a)=>a.status === 'error');
+        if (errorAgents.length > 0) {
+            alerts.push(`${errorAgents.length} agent(s) in error state`);
+        }
+        return alerts;
+    }
+    calculateAverageTaskTime(agents) {
+        const taskTimes = agents.map((a)=>a.performance.averageTaskTime).filter((t)=>t > 0);
+        return taskTimes.length > 0 ? taskTimes.reduce((sum, time)=>sum + time, 0) / taskTimes.length : 0;
+    }
+    calculateCoordinationOverhead(agents) {
+        const totalEvents = agents.reduce((sum, agent)=>sum + agent.performance.coordinationEvents, 0);
+        const totalTasks = agents.reduce((sum, agent)=>sum + agent.performance.tasksCompleted, 0);
+        return totalTasks > 0 ? totalEvents / totalTasks * 100 : 0;
+    }
+    calculateProductivityTrend(agents) {
+        // Simple trend based on success rate
+        const averageSuccess = agents.reduce((sum, agent)=>sum + agent.performance.successRate, 0) / agents.length;
+        if (averageSuccess > 0.8) return 'improving';
+        if (averageSuccess > 0.6) return 'stable';
+        return 'declining';
+    }
+    calculateCoordinationTrend(swarmStatus) {
+        if (swarmStatus.coordination.coordinationEfficiency > 80) return 'efficient';
+        if (swarmStatus.coordination.coordinationEfficiency > 60) return 'moderate';
+        return 'inefficient';
+    }
+    calculateErrorRate(agents) {
+        const errorAgents = agents.filter((a)=>a.status === 'error').length;
+        return agents.length > 0 ? errorAgents / agents.length * 100 : 0;
+    }
+    generatePerformanceRecommendations(swarmStatus) {
+        const recommendations = [];
+        if (swarmStatus.performance.efficiency < 70) {
+            recommendations.push('Consider task rebalancing to improve efficiency');
+        }
+        if (swarmStatus.coordination.activeHandoffs > 10) {
+            recommendations.push('High coordination overhead - simplify agent interactions');
+        }
+        const blockedAgents = swarmStatus.agents.filter((a)=>a.status === 'blocked');
+        if (blockedAgents.length > 0) {
+            recommendations.push('Resolve agent blockers to improve throughput');
+        }
+        if (swarmStatus.relaunchHistory && swarmStatus.relaunchHistory.count > 3) {
+            recommendations.push('Multiple relaunches detected - consider fundamental approach changes');
+        }
+        return recommendations;
+    }
+    parseTimeRange(timeRange) {
+        const now = new Date();
+        const value = parseInt(timeRange.slice(0, -1));
+        const unit = timeRange.slice(-1);
+        switch(unit){
+            case 'h':
+                return new Date(now.getTime() - value * 60 * 60 * 1000);
+            case 'd':
+                return new Date(now.getTime() - value * 24 * 60 * 60 * 1000);
+            case 'm':
+                return new Date(now.getTime() - value * 60 * 1000);
+            default:
+                return new Date(now.getTime() - 60 * 60 * 1000); // Default 1h
+        }
+    }
+    getActiveSwarmCount() {
+        return Array.from(this.swarmStatuses.values()).filter((swarm)=>swarm.status === 'active').length;
+    }
+    constructor(logger){
+        super(), _define_property(this, "logger", void 0), _define_property(this, "agentStatuses", void 0), _define_property(this, "swarmStatuses", void 0), _define_property(this, "statusHistory", void 0), _define_property(this, "MAX_HISTORY_LENGTH", void 0), this.logger = logger, this.agentStatuses = new Map(), this.swarmStatuses = new Map(), this.statusHistory = new Map(), this.MAX_HISTORY_LENGTH = 100;
+        this.setMaxListeners(100);
+    }
+}