claude-flow-novice 1.6.1 → 1.6.2

package/.claude-flow-novice/dist/src/coordination/v2/deadlock/deadlock-detector.js

@@ -0,0 +1,424 @@
+/**
+ * Deadlock Detection Engine
+ *
+ * Implements Tarjan's strongly connected components (SCC) algorithm for efficient
+ * cycle detection in agent dependency graphs. Detects circular wait conditions
+ * in <50ms for graphs with 50+ nodes.
+ *
+ * @module coordination/v2/deadlock/deadlock-detector
+ */ import { EventEmitter } from 'events';
+/**
+ * Deadlock Detection Engine using Tarjan's SCC algorithm
+ *
+ * Efficiently detects circular wait conditions in agent dependency graphs.
+ * Emits events when deadlocks are detected for resolution handling.
+ *
+ * @example
+ * ```typescript
+ * const detector = new DeadlockDetector({
+ *   detectionInterval: 500,
+ *   maxDetectionTime: 50
+ * });
+ *
+ * detector.on('deadlock', (cycle: DeadlockCycle) => {
+ *   console.log(`Deadlock detected: ${cycle.agents.join(' -> ')}`);
+ * });
+ *
+ * // Register agents and dependencies
+ * detector.registerAgent('agent-1', { state: 'waiting', priority: 5 });
+ * detector.addDependency('agent-1', 'agent-2', 'agent');
+ *
+ * // Start automatic detection
+ * detector.startDetection();
+ * ```
+ */ export class DeadlockDetector extends EventEmitter {
+    config;
+    agents = new Map();
+    detectionTimer;
+    metrics;
+    index = 0;
+    stack = [];
+    tarjanData = new Map();
+    operationLock = Promise.resolve();
+    constructor(config = {}){
+        super(), this.config = config;
+        this.metrics = {
+            totalDetections: 0,
+            deadlocksDetected: 0,
+            avgDetectionTime: 0,
+            maxDetectionTime: 0,
+            lastDetectionTime: 0,
+            graphSize: 0
+        };
+    }
+    /**
+   * Register an agent in the dependency graph
+   *
+   * @param agentId - Unique agent identifier
+   * @param options - Agent configuration
+   */ registerAgent(agentId, options = {}) {
+        const maxAgents = this.config.maxAgents || 1000;
+        if (this.agents.size >= maxAgents && !this.agents.has(agentId)) {
+            throw new Error(`Agent limit reached (${maxAgents} max)`);
+        }
+        const node = {
+            agentId,
+            holdingResources: new Set(options.holdingResources || []),
+            waitingForResources: new Set(options.waitingForResources || []),
+            state: options.state || 'idle',
+            stateChangedAt: Date.now(),
+            priority: options.priority
+        };
+        this.agents.set(agentId, node);
+    }
+    /**
+   * Unregister an agent from the dependency graph
+   *
+   * @param agentId - Agent identifier to remove
+   */ unregisterAgent(agentId) {
+        this.agents.delete(agentId);
+    }
+    /**
+   * Add a dependency relationship between agents/resources
+   *
+   * @param fromAgentId - Agent waiting for resource
+   * @param toResourceId - Resource or agent being waited on
+   * @param resourceType - Type of the resource
+   */ async addDependency(fromAgentId, toResourceId, resourceType = 'other') {
+        return this.withLock(async ()=>{
+            const agent = this.agents.get(fromAgentId);
+            if (!agent) {
+                throw new Error(`Agent not registered: ${fromAgentId}`);
+            }
+            // SEC-DOS-001: Enforce edge limit per agent
+            const maxEdgesPerAgent = this.config.maxEdgesPerAgent || 100;
+            if (agent.waitingForResources.size >= maxEdgesPerAgent) {
+                throw new Error(`Edge limit reached for agent ${fromAgentId} (${maxEdgesPerAgent} max)`);
+            }
+            agent.waitingForResources.add(toResourceId);
+            // If resource is another agent, update their holding resources
+            if (resourceType === 'agent') {
+                const targetAgent = this.agents.get(toResourceId);
+                if (targetAgent) {
+                    targetAgent.holdingResources.add(fromAgentId);
+                }
+            }
+        });
+    }
+    /**
+   * Remove a dependency relationship
+   *
+   * @param fromAgentId - Agent that was waiting
+   * @param toResourceId - Resource that was being waited on
+   */ async removeDependency(fromAgentId, toResourceId) {
+        return this.withLock(async ()=>{
+            const agent = this.agents.get(fromAgentId);
+            if (agent) {
+                agent.waitingForResources.delete(toResourceId);
+            }
+            const targetAgent = this.agents.get(toResourceId);
+            if (targetAgent) {
+                targetAgent.holdingResources.delete(fromAgentId);
+            }
+        });
+    }
+    /**
+   * Update agent state
+   *
+   * @param agentId - Agent to update
+   * @param state - New state
+   */ updateAgentState(agentId, state) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+            agent.state = state;
+            agent.stateChangedAt = Date.now();
+        }
+    }
+    /**
+   * Detect deadlocks using Tarjan's SCC algorithm
+   *
+   * Finds all strongly connected components in the wait-for graph.
+   * Components with size ≥ minCycleLength are considered deadlocks.
+   *
+   * @returns Array of detected deadlock cycles
+   */ async detectDeadlocks() {
+        const maxDetectionTime = this.config.maxDetectionTime || 50;
+        const controller = new AbortController();
+        const timeout = setTimeout(()=>controller.abort(), maxDetectionTime);
+        try {
+            return await this.detectWithTimeout(controller.signal);
+        } catch (error) {
+            if (controller.signal.aborted) {
+                this.emit('warning', {
+                    type: 'detection-timeout',
+                    maxTime: maxDetectionTime,
+                    graphSize: this.agents.size
+                });
+                return []; // Return empty on timeout to prevent hanging
+            }
+            throw error;
+        } finally{
+            clearTimeout(timeout);
+        }
+    }
+    /**
+   * Internal detection with timeout enforcement (SEC-DOS-002)
+   *
+   * @param signal - AbortSignal for timeout control
+   * @returns Array of detected deadlock cycles
+   */ async detectWithTimeout(signal) {
+        const startTime = performance.now();
+        const cycles = [];
+        // Reset Tarjan algorithm state
+        this.index = 0;
+        this.stack = [];
+        this.tarjanData.clear();
+        // Run Tarjan's algorithm for each unvisited node
+        for (const agentId of Array.from(this.agents.keys())){
+            if (signal.aborted) {
+                throw new Error('Detection aborted due to timeout');
+            }
+            if (!this.tarjanData.has(agentId)) {
+                this.strongConnect(agentId, cycles);
+            }
+        }
+        // Update metrics
+        const detectionTime = performance.now() - startTime;
+        this.updateMetrics(detectionTime, cycles.length);
+        // Emit deadlock events
+        cycles.forEach((cycle)=>{
+            this.emit('deadlock', cycle);
+        });
+        // Check if detection exceeded time limit
+        if (this.config.maxDetectionTime && detectionTime > this.config.maxDetectionTime) {
+            this.emit('warning', {
+                type: 'slow-detection',
+                detectionTime,
+                maxTime: this.config.maxDetectionTime,
+                graphSize: this.agents.size
+            });
+        }
+        return cycles;
+    }
+    /**
+   * Tarjan's strongly connected components algorithm (recursive DFS)
+   *
+   * @param agentId - Current agent being visited
+   * @param cycles - Array to collect detected cycles
+   */ strongConnect(agentId, cycles) {
+        const agent = this.agents.get(agentId);
+        if (!agent) return;
+        // Initialize node data
+        const nodeData = {
+            index: this.index,
+            lowLink: this.index,
+            onStack: true
+        };
+        this.tarjanData.set(agentId, nodeData);
+        this.index++;
+        this.stack.push(agentId);
+        // Visit all waiting dependencies
+        for (const waitingFor of Array.from(agent.waitingForResources)){
+            // Only follow agent dependencies for cycle detection
+            const waitingAgent = this.agents.get(waitingFor);
+            if (!waitingAgent) continue;
+            const waitingData = this.tarjanData.get(waitingFor);
+            if (!waitingData) {
+                // Not visited yet, recurse
+                this.strongConnect(waitingFor, cycles);
+                const updatedWaitingData = this.tarjanData.get(waitingFor);
+                nodeData.lowLink = Math.min(nodeData.lowLink, updatedWaitingData.lowLink);
+            } else if (waitingData.onStack) {
+                // Already on stack, found back edge
+                nodeData.lowLink = Math.min(nodeData.lowLink, waitingData.index);
+            }
+        }
+        // If this is a root node, extract SCC
+        if (nodeData.lowLink === nodeData.index) {
+            const scc = [];
+            let currentAgentId;
+            do {
+                currentAgentId = this.stack.pop();
+                const currentData = this.tarjanData.get(currentAgentId);
+                currentData.onStack = false;
+                scc.push(currentAgentId);
+            }while (currentAgentId !== agentId)
+            // Check if SCC is a deadlock (cycle with ≥ minCycleLength nodes)
+            const minCycleLength = this.config.minCycleLength || 2;
+            if (scc.length >= minCycleLength) {
+                const cycle = this.createDeadlockCycle(scc);
+                cycles.push(cycle);
+            }
+        }
+    }
+    /**
+   * Create a DeadlockCycle object from detected SCC
+   *
+   * @param agentIds - Agents involved in the cycle
+   * @returns Deadlock cycle metadata
+   */ createDeadlockCycle(agentIds) {
+        const resources = new Set();
+        let totalPriority = 0;
+        // Collect all resources and calculate severity
+        agentIds.forEach((agentId)=>{
+            const agent = this.agents.get(agentId);
+            if (agent) {
+                agent.waitingForResources.forEach((res)=>resources.add(res));
+                totalPriority += agent.priority || 0;
+            }
+        });
+        // Calculate severity (higher for longer cycles and higher priority agents)
+        const severity = agentIds.length * 10 + (totalPriority / agentIds.length || 0);
+        // Determine resolution strategy (prioritize cycle complexity)
+        let resolution = 'abort';
+        if (agentIds.length === 2) {
+            resolution = 'priority-based'; // Simple cycle, use priority
+        } else if (agentIds.length > 5) {
+            resolution = 'timeout'; // Complex cycle, use timeout
+        } else if (severity > 50) {
+            resolution = 'rollback'; // High priority agents, try rollback
+        }
+        return {
+            cycleId: `cycle-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+            agents: agentIds,
+            resources: Array.from(resources),
+            detectedAt: Date.now(),
+            severity,
+            resolution
+        };
+    }
+    /**
+   * Update detection metrics
+   *
+   * @param detectionTime - Time taken for detection in ms
+   * @param cyclesFound - Number of cycles detected
+   */ updateMetrics(detectionTime, cyclesFound) {
+        if (!this.config.enableMetrics) return;
+        this.metrics.totalDetections++;
+        this.metrics.deadlocksDetected += cyclesFound;
+        this.metrics.lastDetectionTime = detectionTime;
+        this.metrics.maxDetectionTime = Math.max(this.metrics.maxDetectionTime, detectionTime);
+        this.metrics.graphSize = this.agents.size;
+        // Calculate running average
+        const totalTime = this.metrics.avgDetectionTime * (this.metrics.totalDetections - 1) + detectionTime;
+        this.metrics.avgDetectionTime = totalTime / this.metrics.totalDetections;
+    }
+    /**
+   * Start automatic deadlock detection
+   *
+   * Runs detection at configured intervals
+   */ startDetection() {
+        if (this.detectionTimer) {
+            return; // Already running
+        }
+        const interval = this.config.detectionInterval || 1000;
+        this.detectionTimer = setInterval(()=>{
+            if (this.agents.size > 0) {
+                this.detectDeadlocks().catch((error)=>{
+                    this.emit('error', {
+                        type: 'detection-error',
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                });
+            }
+        }, interval);
+        this.emit('detection-started', {
+            interval
+        });
+    }
+    /**
+   * Stop automatic deadlock detection
+   */ stopDetection() {
+        if (this.detectionTimer) {
+            clearInterval(this.detectionTimer);
+            this.detectionTimer = undefined;
+            this.emit('detection-stopped');
+        }
+    }
+    /**
+   * Get current detection metrics
+   *
+   * @returns Performance metrics
+   */ getMetrics() {
+        return {
+            ...this.metrics
+        };
+    }
+    /**
+   * Get current dependency graph state
+   *
+   * @returns Map of agent nodes
+   */ getGraph() {
+        return new Map(this.agents);
+    }
+    /**
+   * Clear all agents and dependencies
+   */ clear() {
+        this.agents.clear();
+        this.tarjanData.clear();
+        this.stack = [];
+        this.index = 0;
+    }
+    /**
+   * Export graph to DOT format for visualization
+   *
+   * @returns DOT format string
+   */ toDot() {
+        let dot = 'digraph WaitForGraph {\n';
+        dot += '  rankdir=LR;\n';
+        dot += '  node [shape=box];\n\n';
+        // Add nodes
+        for (const [agentId, agent] of Array.from(this.agents)){
+            let color = 'white';
+            if (agent.state === 'waiting') color = 'yellow';
+            if (agent.state === 'blocked') color = 'red';
+            if (agent.state === 'working') color = 'lightgreen';
+            dot += `  "${agentId}" [style=filled, fillcolor=${color}, label="${agentId}\\n${agent.state}"];\n`;
+        }
+        dot += '\n';
+        // Add edges (wait-for relationships)
+        for (const [agentId, agent] of Array.from(this.agents)){
+            for (const waitingFor of Array.from(agent.waitingForResources)){
+                dot += `  "${agentId}" -> "${waitingFor}" [label="waits for"];\n`;
+            }
+        }
+        dot += '}\n';
+        return dot;
+    }
+    /**
+   * Cleanup resources
+   */ destroy() {
+        this.stopDetection();
+        this.clear();
+        this.removeAllListeners();
+    }
+    /**
+   * Lock helper for atomic operations (SEC-RACE-001 fix)
+   *
+   * Prevents TOCTOU race conditions by ensuring exclusive access
+   * to shared state during critical sections.
+   *
+   * Rust equivalent pattern:
+   * ```rust
+   * async fn with_lock<T, F>(&self, f: F) -> T
+   * where F: FnOnce() -> T {
+   *     let _guard = self.lock.lock().await;
+   *     f()
+   * }
+   * ```
+   */ async withLock(fn) {
+        const currentLock = this.operationLock;
+        let resolveLock;
+        this.operationLock = new Promise((resolve)=>{
+            resolveLock = resolve;
+        });
+        try {
+            await currentLock;
+            return await fn();
+        } finally{
+            resolveLock();
+        }
+    }
+}
+
+//# sourceMappingURL=deadlock-detector.js.map

package/.claude-flow-novice/dist/src/coordination/v2/deadlock/deadlock-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/coordination/v2/deadlock/deadlock-detector.ts"],"names":["EventEmitter","DeadlockDetector","agents","Map","detectionTimer","metrics","index","stack","tarjanData","operationLock","Promise","resolve","config","totalDetections","deadlocksDetected","avgDetectionTime","maxDetectionTime","lastDetectionTime","graphSize","registerAgent","agentId","options","maxAgents","size","has","Error","node","holdingResources","Set","waitingForResources","state","stateChangedAt","Date","now","priority","set","unregisterAgent","delete","addDependency","fromAgentId","toResourceId","resourceType","withLock","agent","get","maxEdgesPerAgent","add","targetAgent","removeDependency","updateAgentState","detectDeadlocks","controller","AbortController","timeout","setTimeout","abort","detectWithTimeout","signal","error","aborted","emit","type","maxTime","clearTimeout","startTime","performance","cycles","clear","Array","from","keys","strongConnect","detectionTime","updateMetrics","length","forEach","cycle","nodeData","lowLink","onStack","push","waitingFor","waitingAgent","waitingData","updatedWaitingData","Math","min","scc","currentAgentId","pop","currentData","minCycleLength","createDeadlockCycle","agentIds","resources","totalPriority","res","severity","resolution","cycleId","random","toString","slice","detectedAt","cyclesFound","enableMetrics","max","totalTime","startDetection","interval","detectionInterval","setInterval","catch","message","String","stopDetection","clearInterval","undefined","getMetrics","getGraph","toDot","dot","color","destroy","removeAllListeners","fn","currentLock","resolveLock"],"mappings":"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"}

package/.claude-flow-novice/dist/src/coordination/v2/deadlock/index.js

@@ -0,0 +1,9 @@
+/**
+ * Deadlock Detection & Recovery Module
+ *
+ * Export deadlock detection components for agent coordination
+ *
+ * @module coordination/v2/deadlock
+ */ export { DeadlockDetector } from './deadlock-detector.js';
+
+//# sourceMappingURL=index.js.map

package/.claude-flow-novice/dist/src/coordination/v2/deadlock/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/coordination/v2/deadlock/index.ts"],"names":["DeadlockDetector"],"mappings":"AAAA;;;;;;CAMC,GAED,SACEA,gBAAgB,QAMX,yBAAyB"}