claude-flow-novice 1.6.1 → 1.6.3

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

@@ -0,0 +1,271 @@
+/**
+ * Agent Coordination V2 - Cycle Detector
+ *
+ * DFS-based cycle detection algorithm for dependency graphs.
+ * Uses three-color marking (white/gray/black) for O(V+E) detection.
+ *
+ * Algorithm:
+ * - White nodes: unvisited
+ * - Gray nodes: currently being visited (on stack)
+ * - Black nodes: fully processed
+ * - Cycle detected when gray node encountered during DFS
+ *
+ * @module coordination/v2/dependency/cycle-detector
+ */ /**
+ * Node color for cycle detection
+ */ var NodeColor = /*#__PURE__*/ function(NodeColor) {
+    /** Unvisited node */ NodeColor["WHITE"] = "white";
+    /** Currently being visited (on DFS stack) */ NodeColor["GRAY"] = "gray";
+    /** Fully processed */ NodeColor["BLACK"] = "black";
+    return NodeColor;
+}(NodeColor || {});
+/**
+ * CycleDetector - DFS-based cycle detection
+ *
+ * Time complexity: O(V + E) where V = nodes, E = edges
+ * Space complexity: O(V) for color map and recursion stack
+ *
+ * Algorithm:
+ * 1. Initialize all nodes as WHITE (unvisited)
+ * 2. For each WHITE node, start DFS
+ * 3. Mark node GRAY (on stack)
+ * 4. Visit all dependencies
+ * 5. If GRAY node encountered -> cycle detected
+ * 6. Mark node BLACK (processed)
+ */ export class CycleDetector {
+    /** Node color map for DFS */ colorMap;
+    /** DFS recursion stack for cycle path reconstruction */ stack;
+    /** Nodes visited during current detection */ nodesVisited;
+    /** Cycle detection metrics */ metrics;
+    constructor(){
+        this.colorMap = new Map();
+        this.stack = [];
+        this.nodesVisited = 0;
+        this.metrics = {
+            totalDetections: 0,
+            cyclesFound: 0,
+            averageLatencyMs: 0
+        };
+    }
+    /**
+   * Detect cycles in dependency graph
+   * O(V + E) time complexity
+   *
+   * @param graph - Dependency graph to analyze
+   * @returns CycleDetectionResult with cycle details
+   */ detectCycle(graph) {
+        const startTime = performance.now();
+        // Reset detection state
+        this.colorMap.clear();
+        this.stack = [];
+        this.nodesVisited = 0;
+        // Initialize all nodes as WHITE
+        const allNodes = graph.getAllNodes();
+        for (const node of allNodes){
+            this.colorMap.set(node.agentId, "white");
+        }
+        // Run DFS from each WHITE node
+        for (const node of allNodes){
+            if (this.colorMap.get(node.agentId) === "white") {
+                const cycleResult = this.dfsVisit(graph, node.agentId);
+                if (cycleResult) {
+                    // Cycle detected
+                    const latencyMs = performance.now() - startTime;
+                    this.updateMetrics(latencyMs, true);
+                    return {
+                        hasCycle: true,
+                        cyclePath: cycleResult,
+                        latencyMs,
+                        nodesVisited: this.nodesVisited,
+                        timestamp: new Date()
+                    };
+                }
+            }
+        }
+        // No cycle found
+        const latencyMs = performance.now() - startTime;
+        this.updateMetrics(latencyMs, false);
+        return {
+            hasCycle: false,
+            latencyMs,
+            nodesVisited: this.nodesVisited,
+            timestamp: new Date()
+        };
+    }
+    /**
+   * DFS visit with three-color marking
+   * Detects cycle when GRAY node encountered
+   *
+   * @param graph - Dependency graph
+   * @param nodeId - Current node being visited
+   * @returns Cycle path if cycle detected, undefined otherwise
+   */ dfsVisit(graph, nodeId) {
+        // Mark node as GRAY (on stack)
+        this.colorMap.set(nodeId, "gray");
+        this.stack.push(nodeId);
+        this.nodesVisited++;
+        // Visit all dependencies (outgoing edges)
+        const dependencies = graph.getDependencies(nodeId);
+        for (const depId of dependencies){
+            const depColor = this.colorMap.get(depId);
+            if (depColor === "gray") {
+                // CYCLE DETECTED: Gray node encountered (on stack)
+                const cycleStartIndex = this.stack.indexOf(depId);
+                const cyclePath = this.stack.slice(cycleStartIndex);
+                cyclePath.push(depId); // Close the cycle
+                return cyclePath;
+            }
+            if (depColor === "white") {
+                // Unvisited node - continue DFS
+                const cycleResult = this.dfsVisit(graph, depId);
+                if (cycleResult) {
+                    return cycleResult; // Propagate cycle up the call stack
+                }
+            }
+        // BLACK nodes are already processed - skip
+        }
+        // Mark node as BLACK (fully processed)
+        this.colorMap.set(nodeId, "black");
+        this.stack.pop();
+        return undefined; // No cycle found from this node
+    }
+    /**
+   * Get detailed cycle information
+   *
+   * @param cyclePath - Cycle path from detection
+   * @returns CycleDetails with formatted cycle information
+   */ getCycleDetails(cyclePath) {
+        if (cyclePath.length < 2) {
+            throw new Error('Invalid cycle path: must contain at least 2 nodes');
+        }
+        return {
+            agents: cyclePath,
+            startNode: cyclePath[0],
+            endNode: cyclePath[cyclePath.length - 1],
+            length: cyclePath.length - 1,
+            detectedAt: new Date()
+        };
+    }
+    /**
+   * Detect all cycles in graph (not just first one)
+   * More expensive: O(V * (V + E))
+   *
+   * @param graph - Dependency graph to analyze
+   * @returns Array of all detected cycles
+   */ detectAllCycles(graph) {
+        const cycles = [];
+        const visited = new Set();
+        const allNodes = graph.getAllNodes();
+        for (const node of allNodes){
+            if (!visited.has(node.agentId)) {
+                // Reset for each new DFS tree
+                this.colorMap.clear();
+                this.stack = [];
+                for (const n of allNodes){
+                    this.colorMap.set(n.agentId, "white");
+                }
+                const cycleResult = this.dfsVisit(graph, node.agentId);
+                if (cycleResult) {
+                    cycles.push(this.getCycleDetails(cycleResult));
+                    // Mark all nodes in cycle as visited
+                    for (const agentId of cycleResult){
+                        visited.add(agentId);
+                    }
+                }
+            }
+        }
+        return cycles;
+    }
+    /**
+   * Check if specific path would create cycle
+   * Used for pre-validation before adding edges
+   *
+   * @param graph - Current dependency graph
+   * @param from - Source agent
+   * @param to - Target agent
+   * @returns True if adding edge would create cycle
+   */ wouldCreateCycle(graph, from, to) {
+        // Adding edge from -> to creates cycle if:
+        // There's already a path from to -> from
+        // Check if 'to' can reach 'from' via existing dependencies
+        const reachable = this.getReachableNodes(graph, to);
+        return reachable.has(from);
+    }
+    /**
+   * Get all nodes reachable from start node
+   * Uses BFS for efficient traversal
+   *
+   * @param graph - Dependency graph
+   * @param startNode - Starting node
+   * @returns Set of reachable node IDs
+   */ getReachableNodes(graph, startNode) {
+        const reachable = new Set();
+        const queue = [
+            startNode
+        ];
+        const visited = new Set();
+        while(queue.length > 0){
+            const current = queue.shift();
+            if (visited.has(current)) {
+                continue;
+            }
+            visited.add(current);
+            reachable.add(current);
+            // Add all dependencies to queue
+            const dependencies = graph.getDependencies(current);
+            for (const dep of dependencies){
+                if (!visited.has(dep)) {
+                    queue.push(dep);
+                }
+            }
+        }
+        return reachable;
+    }
+    /**
+   * Update cycle detection metrics
+   */ updateMetrics(latencyMs, cycleFound) {
+        this.metrics.totalDetections++;
+        if (cycleFound) {
+            this.metrics.cyclesFound++;
+        }
+        // Update running average
+        this.metrics.averageLatencyMs = (this.metrics.averageLatencyMs * (this.metrics.totalDetections - 1) + latencyMs) / this.metrics.totalDetections;
+    }
+    /**
+   * Get cycle detection metrics
+   */ getMetrics() {
+        return {
+            ...this.metrics
+        };
+    }
+    /**
+   * Reset detector state
+   */ reset() {
+        this.colorMap.clear();
+        this.stack = [];
+        this.nodesVisited = 0;
+    }
+}
+/**
+ * Utility function to detect cycle in graph
+ * Convenience wrapper around CycleDetector
+ *
+ * @param graph - Dependency graph to check
+ * @returns CycleDetectionResult
+ */ export function detectCycle(graph) {
+    const detector = new CycleDetector();
+    return detector.detectCycle(graph);
+}
+/**
+ * Utility function to check if adding edge would create cycle
+ *
+ * @param graph - Current dependency graph
+ * @param from - Source agent
+ * @param to - Target agent
+ * @returns True if edge would create cycle
+ */ export function wouldCreateCycle(graph, from, to) {
+    const detector = new CycleDetector();
+    return detector.wouldCreateCycle(graph, from, to);
+}
+
+//# sourceMappingURL=cycle-detector.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/coordination/v2/dependency/cycle-detector.ts"],"names":["NodeColor","CycleDetector","colorMap","stack","nodesVisited","metrics","Map","totalDetections","cyclesFound","averageLatencyMs","detectCycle","graph","startTime","performance","now","clear","allNodes","getAllNodes","node","set","agentId","get","cycleResult","dfsVisit","latencyMs","updateMetrics","hasCycle","cyclePath","timestamp","Date","nodeId","push","dependencies","getDependencies","depId","depColor","cycleStartIndex","indexOf","slice","pop","undefined","getCycleDetails","length","Error","agents","startNode","endNode","detectedAt","detectAllCycles","cycles","visited","Set","has","n","add","wouldCreateCycle","from","to","reachable","getReachableNodes","queue","current","shift","dep","cycleFound","getMetrics","reset","detector"],"mappings":"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"}

package/.claude-flow-novice/dist/src/coordination/v2/dependency/dependency-graph.js

@@ -0,0 +1,335 @@
+/**
+ * Agent Coordination V2 - Dependency Graph (DAG)
+ *
+ * Directed Acyclic Graph (DAG) data structure for managing agent dependencies.
+ * Uses adjacency list representation for O(V+E) space complexity.
+ *
+ * Features:
+ * - Adjacency list representation
+ * - Topological sorting
+ * - Transitive dependency resolution
+ * - Cycle detection integration
+ *
+ * @module coordination/v2/dependency/dependency-graph
+ */ /**
+ * DependencyGraph - DAG implementation using adjacency list
+ *
+ * Space complexity: O(V + E) where V = nodes, E = edges
+ * Time complexity:
+ * - addNode: O(1)
+ * - addEdge: O(1)
+ * - removeEdge: O(1)
+ * - getDependencies: O(1)
+ * - topologicalSort: O(V + E)
+ */ export class DependencyGraph {
+    /** Adjacency list: agentId -> DependencyNode */ nodes;
+    /** Edge list for quick edge lookups */ edges;
+    /** Graph creation timestamp */ createdAt;
+    /** Graph metrics */ metrics;
+    constructor(){
+        this.nodes = new Map();
+        this.edges = new Map();
+        this.createdAt = new Date();
+        this.metrics = {
+            totalNodesAdded: 0,
+            totalEdgesAdded: 0,
+            totalNodesRemoved: 0,
+            totalEdgesRemoved: 0
+        };
+    }
+    /**
+   * Add node to graph
+   * O(1) time complexity
+   */ addNode(agentId, priority = 5) {
+        if (this.nodes.has(agentId)) {
+            return; // Node already exists
+        }
+        const node = {
+            agentId,
+            dependencies: new Set(),
+            dependents: new Set(),
+            requests: new Map(),
+            metadata: {
+                createdAt: new Date(),
+                lastUpdated: new Date(),
+                priority
+            }
+        };
+        this.nodes.set(agentId, node);
+        this.metrics.totalNodesAdded++;
+    }
+    /**
+   * Add directed edge: from -> to (from depends on to)
+   * O(1) time complexity
+   *
+   * @throws Error if edge would create cycle
+   */ addEdge(from, to, request) {
+        // Ensure both nodes exist
+        this.addNode(from);
+        this.addNode(to);
+        const edgeKey = `${from}->${to}`;
+        // Skip if edge already exists
+        if (this.edges.has(edgeKey)) {
+            return;
+        }
+        // Create edge
+        const edge = {
+            from,
+            to,
+            requestId: request.requestId,
+            weight: request.priority,
+            createdAt: new Date()
+        };
+        // Update adjacency lists
+        const fromNode = this.nodes.get(from);
+        const toNode = this.nodes.get(to);
+        fromNode.dependencies.add(to);
+        fromNode.requests.set(request.requestId, request);
+        fromNode.metadata.lastUpdated = new Date();
+        toNode.dependents.add(from);
+        toNode.metadata.lastUpdated = new Date();
+        // Store edge
+        this.edges.set(edgeKey, edge);
+        this.metrics.totalEdgesAdded++;
+    }
+    /**
+   * Remove edge from graph
+   * O(1) time complexity
+   */ removeEdge(from, to) {
+        const edgeKey = `${from}->${to}`;
+        if (!this.edges.has(edgeKey)) {
+            return false;
+        }
+        // Update adjacency lists
+        const fromNode = this.nodes.get(from);
+        const toNode = this.nodes.get(to);
+        if (fromNode) {
+            fromNode.dependencies.delete(to);
+            fromNode.metadata.lastUpdated = new Date();
+        }
+        if (toNode) {
+            toNode.dependents.delete(from);
+            toNode.metadata.lastUpdated = new Date();
+        }
+        // Remove edge
+        this.edges.delete(edgeKey);
+        this.metrics.totalEdgesRemoved++;
+        return true;
+    }
+    /**
+   * Remove node and all associated edges
+   * O(E) time complexity where E = edges connected to node
+   */ removeNode(agentId) {
+        const node = this.nodes.get(agentId);
+        if (!node) {
+            return false;
+        }
+        // Remove all incoming edges (from dependents)
+        for (const dependent of node.dependents){
+            this.removeEdge(dependent, agentId);
+        }
+        // Remove all outgoing edges (to dependencies)
+        for (const dependency of node.dependencies){
+            this.removeEdge(agentId, dependency);
+        }
+        // Remove node
+        this.nodes.delete(agentId);
+        this.metrics.totalNodesRemoved++;
+        return true;
+    }
+    /**
+   * Get direct dependencies for an agent
+   * O(1) time complexity
+   */ getDependencies(agentId) {
+        const node = this.nodes.get(agentId);
+        return node ? new Set(node.dependencies) : new Set();
+    }
+    /**
+   * Get direct dependents for an agent
+   * O(1) time complexity
+   */ getDependents(agentId) {
+        const node = this.nodes.get(agentId);
+        return node ? new Set(node.dependents) : new Set();
+    }
+    /**
+   * Get all transitive dependencies (recursive)
+   * O(V + E) time complexity with memoization
+   */ getTransitiveDependencies(agentId) {
+        const visited = new Set();
+        const transitive = new Set();
+        const traverse = (nodeId)=>{
+            if (visited.has(nodeId)) {
+                return;
+            }
+            visited.add(nodeId);
+            const dependencies = this.getDependencies(nodeId);
+            for (const dep of dependencies){
+                transitive.add(dep);
+                traverse(dep);
+            }
+        };
+        traverse(agentId);
+        return transitive;
+    }
+    /**
+   * Check if agent has any dependencies
+   */ hasDependencies(agentId) {
+        const node = this.nodes.get(agentId);
+        return node ? node.dependencies.size > 0 : false;
+    }
+    /**
+   * Check if agent has any dependents
+   */ hasDependents(agentId) {
+        const node = this.nodes.get(agentId);
+        return node ? node.dependents.size > 0 : false;
+    }
+    /**
+   * Get node by agent ID
+   */ getNode(agentId) {
+        return this.nodes.get(agentId);
+    }
+    /**
+   * Get edge between two agents
+   */ getEdge(from, to) {
+        return this.edges.get(`${from}->${to}`);
+    }
+    /**
+   * Get all nodes in graph
+   */ getAllNodes() {
+        return Array.from(this.nodes.values());
+    }
+    /**
+   * Get all edges in graph
+   */ getAllEdges() {
+        return Array.from(this.edges.values());
+    }
+    /**
+   * Topological sort using Kahn's algorithm
+   * O(V + E) time complexity
+   *
+   * @returns TopologicalSortResult with sorted order or cycle info
+   */ topologicalSort() {
+        // Calculate in-degree for each node
+        const inDegree = new Map();
+        const queue = [];
+        for (const [agentId, node] of this.nodes){
+            inDegree.set(agentId, node.dependencies.size);
+            if (node.dependencies.size === 0) {
+                queue.push(agentId);
+            }
+        }
+        const order = [];
+        // Process nodes with in-degree 0
+        while(queue.length > 0){
+            const current = queue.shift();
+            order.push(current);
+            // Reduce in-degree for all dependents
+            const dependents = this.getDependents(current);
+            for (const dependent of dependents){
+                const degree = inDegree.get(dependent) - 1;
+                inDegree.set(dependent, degree);
+                if (degree === 0) {
+                    queue.push(dependent);
+                }
+            }
+        }
+        // If all nodes processed, graph is acyclic
+        if (order.length === this.nodes.size) {
+            return {
+                success: true,
+                order
+            };
+        }
+        // Cycle detected - find remaining nodes
+        const remainingNodes = Array.from(this.nodes.keys()).filter((agentId)=>!order.includes(agentId));
+        return {
+            success: false,
+            cycle: {
+                agents: remainingNodes,
+                detectedAt: new Date()
+            }
+        };
+    }
+    /**
+   * Get graph statistics
+   */ getStatistics() {
+        const sourceNodes = [];
+        const sinkNodes = [];
+        let totalDependencies = 0;
+        let maxDepth = 0;
+        for (const [agentId, node] of this.nodes){
+            // Source nodes: no dependencies
+            if (node.dependencies.size === 0) {
+                sourceNodes.push(agentId);
+            }
+            // Sink nodes: no dependents
+            if (node.dependents.size === 0) {
+                sinkNodes.push(agentId);
+            }
+            totalDependencies += node.dependencies.size;
+            // Calculate depth from source nodes
+            const depth = this.calculateDepth(agentId);
+            if (depth > maxDepth) {
+                maxDepth = depth;
+            }
+        }
+        return {
+            nodeCount: this.nodes.size,
+            edgeCount: this.edges.size,
+            maxDepth,
+            averageDependencies: this.nodes.size > 0 ? totalDependencies / this.nodes.size : 0,
+            sourceNodes,
+            sinkNodes
+        };
+    }
+    /**
+   * Calculate depth of node from source nodes
+   * O(V + E) time complexity
+   */ calculateDepth(agentId) {
+        const visited = new Set();
+        const dfs = (nodeId)=>{
+            if (visited.has(nodeId)) {
+                return 0; // Avoid cycles
+            }
+            visited.add(nodeId);
+            const dependencies = this.getDependencies(nodeId);
+            if (dependencies.size === 0) {
+                return 0; // Source node
+            }
+            let maxDepth = 0;
+            for (const dep of dependencies){
+                const depth = dfs(dep) + 1;
+                if (depth > maxDepth) {
+                    maxDepth = depth;
+                }
+            }
+            return maxDepth;
+        };
+        return dfs(agentId);
+    }
+    /**
+   * Get graph metrics
+   */ getMetrics() {
+        return {
+            ...this.metrics
+        };
+    }
+    /**
+   * Clear entire graph
+   */ clear() {
+        this.nodes.clear();
+        this.edges.clear();
+    }
+    /**
+   * Get graph size
+   */ size() {
+        return this.nodes.size;
+    }
+    /**
+   * Check if graph is empty
+   */ isEmpty() {
+        return this.nodes.size === 0;
+    }
+}
+
+//# sourceMappingURL=dependency-graph.js.map

package/.claude-flow-novice/dist/src/coordination/v2/dependency/dependency-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/coordination/v2/dependency/dependency-graph.ts"],"names":["DependencyGraph","nodes","edges","createdAt","metrics","Map","Date","totalNodesAdded","totalEdgesAdded","totalNodesRemoved","totalEdgesRemoved","addNode","agentId","priority","has","node","dependencies","Set","dependents","requests","metadata","lastUpdated","set","addEdge","from","to","request","edgeKey","edge","requestId","weight","fromNode","get","toNode","add","removeEdge","delete","removeNode","dependent","dependency","getDependencies","getDependents","getTransitiveDependencies","visited","transitive","traverse","nodeId","dep","hasDependencies","size","hasDependents","getNode","getEdge","getAllNodes","Array","values","getAllEdges","topologicalSort","inDegree","queue","push","order","length","current","shift","degree","success","remainingNodes","keys","filter","includes","cycle","agents","detectedAt","getStatistics","sourceNodes","sinkNodes","totalDependencies","maxDepth","depth","calculateDepth","nodeCount","edgeCount","averageDependencies","dfs","getMetrics","clear","isEmpty"],"mappings":"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"}