claude-flow-novice 1.6.1 → 1.6.3

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

@@ -0,0 +1,223 @@
+/**
+ * Agent Coordination V2 - Topological Sort Implementation
+ *
+ * Kahn's algorithm for topological sorting of dependency graphs.
+ * Provides O(V+E) complexity for computing execution ordering.
+ *
+ * @module coordination/v2/dependency/topological-sort
+ */ /**
+ * Topological Sort using Kahn's Algorithm.
+ *
+ * Kahn's algorithm works by:
+ * 1. Computing in-degree for all nodes
+ * 2. Starting with nodes having in-degree 0 (no dependencies)
+ * 3. Removing nodes from queue and decrementing in-degrees
+ * 4. Adding nodes with in-degree 0 to queue
+ * 5. Repeating until all nodes processed or cycle detected
+ *
+ * Time Complexity: O(V + E)
+ * Space Complexity: O(V)
+ *
+ * @example
+ * ```typescript
+ * const sorter = new TopologicalSort(graph);
+ * const result = sorter.sort();
+ *
+ * if (result.success) {
+ *   console.log('Execution order:', result.order);
+ * } else {
+ *   console.error('Cycle detected:', result.cycles);
+ * }
+ * ```
+ */ export class TopologicalSort {
+    graph;
+    /**
+   * Creates a new topological sorter.
+   *
+   * @param graph - Dependency graph to sort
+   */ constructor(graph){
+        this.graph = graph;
+    }
+    /**
+   * Performs topological sort using Kahn's algorithm.
+   *
+   * Returns nodes in dependency order (dependencies before dependents).
+   * If graph contains cycles, sort fails and cycles are reported.
+   *
+   * Algorithm:
+   * 1. Calculate in-degree for each node (count of incoming edges)
+   * 2. Queue all nodes with in-degree 0 (no dependencies)
+   * 3. While queue not empty:
+   *    a. Dequeue node and add to result
+   *    b. For each dependent of node:
+   *       - Decrement its in-degree
+   *       - If in-degree becomes 0, enqueue it
+   * 4. If result contains all nodes → success
+   *    Else → cycle exists
+   *
+   * @returns Topological sort result
+   */ sort() {
+        const inDegree = new Map();
+        const queue = [];
+        const result = [];
+        // Step 1: Initialize in-degrees
+        for (const nodeId of this.graph.getAllNodes().map((n)=>n.id)){
+            const dependencies = this.graph.getDependencies(nodeId);
+            inDegree.set(nodeId, dependencies.size);
+            // Step 2: Enqueue nodes with no dependencies
+            if (dependencies.size === 0) {
+                queue.push(nodeId);
+            }
+        }
+        // Step 3: Process nodes with zero in-degree (BFS)
+        while(queue.length > 0){
+            const nodeId = queue.shift();
+            result.push(nodeId);
+            // Step 4: Update in-degrees for dependents
+            const dependents = this.graph.getDependents(nodeId);
+            for (const dependentId of dependents){
+                const currentInDegree = inDegree.get(dependentId);
+                const newInDegree = currentInDegree - 1;
+                inDegree.set(dependentId, newInDegree);
+                // Enqueue if all dependencies satisfied
+                if (newInDegree === 0) {
+                    queue.push(dependentId);
+                }
+            }
+        }
+        // Step 5: Validate result (all nodes processed?)
+        const totalNodes = this.graph.size();
+        const success = result.length === totalNodes;
+        if (!success) {
+            // Cycle detected - identify cycles
+            const cycleDetection = this.graph.detectCycles();
+            return {
+                order: result,
+                success: false,
+                error: `Cannot compute topological order: graph contains cycles. Processed ${result.length}/${totalNodes} nodes.`,
+                cycles: cycleDetection.cycles
+            };
+        }
+        return {
+            order: result,
+            success: true
+        };
+    }
+    /**
+   * Validates if graph is acyclic (DAG).
+   *
+   * @returns True if graph is a DAG (can be topologically sorted)
+   */ isDAG() {
+        return this.sort().success;
+    }
+    /**
+   * Gets ready nodes (nodes with all dependencies satisfied).
+   *
+   * This is useful for incremental execution - get next batch of
+   * executable tasks without sorting the entire graph.
+   *
+   * @param completed - Set of already completed node IDs
+   * @returns Array of node IDs ready for execution
+   */ getReadyNodes(completed) {
+        const ready = [];
+        for (const node of this.graph.getAllNodes()){
+            // Skip completed nodes
+            if (completed.has(node.id)) {
+                continue;
+            }
+            // Check if all dependencies are completed
+            const dependencies = this.graph.getDependencies(node.id);
+            let allDepsCompleted = true;
+            for (const depId of dependencies){
+                if (!completed.has(depId)) {
+                    allDepsCompleted = false;
+                    break;
+                }
+            }
+            if (allDepsCompleted) {
+                ready.push(node.id);
+            }
+        }
+        return ready;
+    }
+    /**
+   * Computes partial topological order for a subset of nodes.
+   *
+   * This is useful when you only care about ordering a subset of nodes
+   * (e.g., tasks for a specific agent).
+   *
+   * @param nodeIds - Subset of node IDs to order
+   * @returns Topological order for subset (or null if cycles exist)
+   */ sortSubset(nodeIds) {
+        const subsetInDegree = new Map();
+        const queue = [];
+        const result = [];
+        // Initialize in-degrees for subset only
+        for (const nodeId of nodeIds){
+            const dependencies = this.graph.getDependencies(nodeId);
+            // Count dependencies within subset
+            let inDegreeCount = 0;
+            for (const depId of dependencies){
+                if (nodeIds.has(depId)) {
+                    inDegreeCount++;
+                }
+            }
+            subsetInDegree.set(nodeId, inDegreeCount);
+            if (inDegreeCount === 0) {
+                queue.push(nodeId);
+            }
+        }
+        // BFS processing
+        while(queue.length > 0){
+            const nodeId = queue.shift();
+            result.push(nodeId);
+            const dependents = this.graph.getDependents(nodeId);
+            for (const dependentId of dependents){
+                if (!nodeIds.has(dependentId)) continue;
+                const currentInDegree = subsetInDegree.get(dependentId);
+                const newInDegree = currentInDegree - 1;
+                subsetInDegree.set(dependentId, newInDegree);
+                if (newInDegree === 0) {
+                    queue.push(dependentId);
+                }
+            }
+        }
+        // Validate complete
+        if (result.length !== nodeIds.size) {
+            return null; // Cycle in subset
+        }
+        return result;
+    }
+    /**
+   * Computes execution levels (nodes at same depth can run in parallel).
+   *
+   * Returns nodes grouped by execution level:
+   * - Level 0: Nodes with no dependencies
+   * - Level 1: Nodes depending only on Level 0
+   * - Level N: Nodes depending on Level N-1 or earlier
+   *
+   * @returns Array of levels, each containing node IDs at that level
+   */ computeLevels() {
+        const levels = [];
+        const nodeLevel = new Map();
+        const completed = new Set();
+        // Process nodes level by level
+        let currentLevel = 0;
+        while(completed.size < this.graph.size()){
+            const levelNodes = this.getReadyNodes(completed);
+            if (levelNodes.length === 0) {
+                break;
+            }
+            levels.push(levelNodes);
+            // Mark nodes as completed and assign level
+            for (const nodeId of levelNodes){
+                completed.add(nodeId);
+                nodeLevel.set(nodeId, currentLevel);
+            }
+            currentLevel++;
+        }
+        return levels;
+    }
+}
+
+//# sourceMappingURL=topological-sort.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/coordination/v2/dependency/topological-sort.ts"],"names":["TopologicalSort","graph","sort","inDegree","Map","queue","result","nodeId","getAllNodes","map","n","id","dependencies","getDependencies","set","size","push","length","shift","dependents","getDependents","dependentId","currentInDegree","get","newInDegree","totalNodes","success","cycleDetection","detectCycles","order","error","cycles","isDAG","getReadyNodes","completed","ready","node","has","allDepsCompleted","depId","sortSubset","nodeIds","subsetInDegree","inDegreeCount","computeLevels","levels","nodeLevel","Set","currentLevel","levelNodes","add"],"mappings":"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"}

package/.claude-flow-novice/dist/src/coordination/v2/help-system/help-coordinator.js

@@ -0,0 +1,436 @@
+/**
+ * Agent Coordination V2 - Help Coordinator
+ *
+ * Help routing and lifecycle management with MessageBroker integration.
+ * Target: <200ms p95 latency for routing help requests to best-match agents.
+ *
+ * @module coordination/v2/help-system/help-coordinator
+ */ import { HelpRequest, HelpRequestPriority } from './help-request.js';
+import { HelpMatcher } from './help-matcher.js';
+import { MessagePriority } from '../core/message.js';
+/**
+ * Help coordinator implementation with routing and lifecycle management
+ */ export class HelpCoordinator {
+    /** Help request matcher */ matcher;
+    /** Active help requests */ activeRequests;
+    /** Request queue (overflow when max concurrent reached) */ requestQueue;
+    /** Routing results history */ routingHistory;
+    /** Coordinator configuration */ config;
+    /** Performance metrics */ metrics;
+    /** Recent routing latencies for percentile calculation */ recentLatencies;
+    /** Request ID counter */ requestCounter;
+    constructor(config){
+        this.matcher = new HelpMatcher(config?.matcherConfig);
+        this.activeRequests = new Map();
+        this.requestQueue = [];
+        this.routingHistory = [];
+        this.recentLatencies = [];
+        this.requestCounter = 0;
+        this.config = {
+            matcherConfig: config?.matcherConfig ?? {},
+            maxConcurrentRequests: config?.maxConcurrentRequests ?? 100,
+            autoRetry: config?.autoRetry ?? true,
+            maxRoutingAttempts: config?.maxRoutingAttempts ?? 3,
+            enableQueue: config?.enableQueue ?? true,
+            maxQueueSize: config?.maxQueueSize ?? 500,
+            messageBroker: config?.messageBroker,
+            enableEventPublishing: config?.enableEventPublishing ?? config?.messageBroker !== undefined
+        };
+        this.metrics = {
+            totalRequests: 0,
+            successfulRoutes: 0,
+            failedRoutes: 0,
+            averageRoutingLatencyMs: 0,
+            p95RoutingLatencyMs: 0,
+            p99RoutingLatencyMs: 0,
+            activeRequests: 0,
+            queuedRequests: 0,
+            resolvedRequests: 0,
+            expiredRequests: 0
+        };
+    }
+    /**
+   * Create and route help request
+   * Target: <200ms p95 latency
+   */ async createHelpRequest(requesterId, description, capabilities, priority = HelpRequestPriority.NORMAL, metadata) {
+        const startTime = performance.now();
+        // Generate unique request ID
+        const requestId = this.generateRequestId();
+        // Create help request
+        const request = new HelpRequest({
+            requestId,
+            requesterId,
+            priority,
+            capabilities,
+            description,
+            metadata
+        });
+        this.metrics.totalRequests++;
+        // Check concurrent request limit
+        if (this.activeRequests.size >= this.config.maxConcurrentRequests) {
+            if (this.config.enableQueue && this.requestQueue.length < this.config.maxQueueSize) {
+                this.requestQueue.push(request);
+                this.metrics.queuedRequests++;
+                return {
+                    routingId: this.generateRoutingId(),
+                    request,
+                    match: null,
+                    status: 'no_match',
+                    latencyMs: performance.now() - startTime,
+                    timestamp: new Date(),
+                    error: 'Request queued - max concurrent requests reached'
+                };
+            }
+            return {
+                routingId: this.generateRoutingId(),
+                request,
+                match: null,
+                status: 'failed',
+                latencyMs: performance.now() - startTime,
+                timestamp: new Date(),
+                error: 'Max concurrent requests reached and queue is full'
+            };
+        }
+        // Route request to best match
+        const result = await this.routeRequest(request);
+        const latency = performance.now() - startTime;
+        result.latencyMs = latency;
+        this.recordRoutingMetrics(latency, result.status === 'success');
+        return result;
+    }
+    /**
+   * Route help request to best matching agent
+   */ async routeRequest(request) {
+        const routingId = this.generateRoutingId();
+        const startTime = performance.now();
+        try {
+            // Find best match
+            const match = await this.matcher.findMatch(request);
+            if (!match) {
+                this.metrics.failedRoutes++;
+                return {
+                    routingId,
+                    request,
+                    match: null,
+                    status: 'no_match',
+                    latencyMs: performance.now() - startTime,
+                    timestamp: new Date(),
+                    error: 'No matching agent found'
+                };
+            }
+            // Mark request as matched
+            request.markMatched(match.agentId);
+            // Track active request
+            this.activeRequests.set(request.requestId, request);
+            this.metrics.activeRequests = this.activeRequests.size;
+            this.metrics.successfulRoutes++;
+            const result = {
+                routingId,
+                request,
+                match,
+                status: 'success',
+                latencyMs: performance.now() - startTime,
+                timestamp: new Date()
+            };
+            this.routingHistory.push(result);
+            // Publish routing success event via MessageBroker
+            await this.publishRoutingEvent(result);
+            return result;
+        } catch (error) {
+            this.metrics.failedRoutes++;
+            return {
+                routingId,
+                request,
+                match: null,
+                status: 'failed',
+                latencyMs: performance.now() - startTime,
+                timestamp: new Date(),
+                error: error instanceof Error ? error.message : 'Unknown routing error'
+            };
+        }
+    }
+    /**
+   * Mark help request as in progress
+   */ async startHelp(requestId) {
+        const request = this.activeRequests.get(requestId);
+        if (!request) {
+            throw new Error(`Help request ${requestId} not found`);
+        }
+        request.markInProgress();
+        // Publish help started event
+        await this.publishHelpStartedEvent(request);
+    }
+    /**
+   * Mark help request as resolved
+   */ async resolveHelp(requestId, metadata) {
+        const request = this.activeRequests.get(requestId);
+        if (!request) {
+            throw new Error(`Help request ${requestId} not found`);
+        }
+        request.markResolved(metadata);
+        this.activeRequests.delete(requestId);
+        this.metrics.activeRequests = this.activeRequests.size;
+        this.metrics.resolvedRequests++;
+        // Publish help resolved event
+        await this.publishHelpResolvedEvent(request, metadata);
+        // Process next queued request
+        this.processQueue();
+    }
+    /**
+   * Mark help request as failed
+   */ async failHelp(requestId, reason, metadata) {
+        const request = this.activeRequests.get(requestId);
+        if (!request) {
+            throw new Error(`Help request ${requestId} not found`);
+        }
+        request.markFailed(reason, metadata);
+        this.activeRequests.delete(requestId);
+        this.metrics.activeRequests = this.activeRequests.size;
+        // Publish help failed event
+        await this.publishHelpFailedEvent(request, reason, metadata);
+        // Retry if enabled and possible
+        if (this.config.autoRetry && request.canRetry()) {
+            const retried = await request.retry();
+            if (retried) {
+                // Re-route retried request
+                await this.routeRequest(request);
+            }
+        }
+        // Process next queued request
+        this.processQueue();
+    }
+    /**
+   * Cancel help request
+   */ async cancelHelp(requestId, reason) {
+        const request = this.activeRequests.get(requestId);
+        if (!request) {
+            throw new Error(`Help request ${requestId} not found`);
+        }
+        request.cancel(reason);
+        this.activeRequests.delete(requestId);
+        this.metrics.activeRequests = this.activeRequests.size;
+        // Process next queued request
+        this.processQueue();
+    }
+    /**
+   * Get help request status
+   */ getRequestStatus(requestId) {
+        const request = this.activeRequests.get(requestId);
+        return request ? request.status : null;
+    }
+    /**
+   * Get help request details
+   */ getRequest(requestId) {
+        return this.activeRequests.get(requestId) || null;
+    }
+    /**
+   * Register agent profile for matching
+   */ registerAgent(profile) {
+        this.matcher.registerAgent(profile);
+    }
+    /**
+   * Unregister agent profile
+   */ unregisterAgent(agentId) {
+        this.matcher.unregisterAgent(agentId);
+    }
+    /**
+   * Update agent state
+   */ updateAgentState(agentId, state) {
+        this.matcher.updateAgentState(agentId, state);
+    }
+    /**
+   * Update agent workload
+   */ updateAgentWorkload(agentId, workload) {
+        this.matcher.updateAgentWorkload(agentId, workload);
+    }
+    /**
+   * Process queued requests
+   */ async processQueue() {
+        if (this.requestQueue.length === 0) {
+            return;
+        }
+        if (this.activeRequests.size >= this.config.maxConcurrentRequests) {
+            return;
+        }
+        // Process highest priority queued request
+        this.requestQueue.sort((a, b)=>b.priority - a.priority);
+        const nextRequest = this.requestQueue.shift();
+        if (nextRequest) {
+            this.metrics.queuedRequests = this.requestQueue.length;
+            await this.routeRequest(nextRequest);
+        }
+    }
+    /**
+   * Record routing metrics
+   */ recordRoutingMetrics(latencyMs, success) {
+        this.recentLatencies.push(latencyMs);
+        // Keep only last 1000 latencies
+        if (this.recentLatencies.length > 1000) {
+            this.recentLatencies.shift();
+        }
+        // Update average latency
+        const totalRoutes = this.metrics.successfulRoutes + this.metrics.failedRoutes;
+        this.metrics.averageRoutingLatencyMs = (this.metrics.averageRoutingLatencyMs * (totalRoutes - 1) + latencyMs) / totalRoutes;
+        // Update percentiles
+        const sorted = [
+            ...this.recentLatencies
+        ].sort((a, b)=>a - b);
+        this.metrics.p95RoutingLatencyMs = sorted[Math.floor(sorted.length * 0.95)] || 0;
+        this.metrics.p99RoutingLatencyMs = sorted[Math.floor(sorted.length * 0.99)] || 0;
+    }
+    /**
+   * Generate unique request ID
+   */ generateRequestId() {
+        return `help_req_${Date.now()}_${++this.requestCounter}`;
+    }
+    /**
+   * Generate unique routing ID
+   */ generateRoutingId() {
+        return `route_${Date.now()}_${this.requestCounter}`;
+    }
+    /**
+   * Get coordinator metrics
+   */ getMetrics() {
+        return {
+            ...this.metrics,
+            matcherMetrics: this.matcher.getMetrics()
+        };
+    }
+    /**
+   * Get all active requests
+   */ getActiveRequests() {
+        return Array.from(this.activeRequests.values());
+    }
+    /**
+   * Get queued requests
+   */ getQueuedRequests() {
+        return [
+            ...this.requestQueue
+        ];
+    }
+    /**
+   * Get routing history
+   */ getRoutingHistory(limit) {
+        return limit ? this.routingHistory.slice(-limit) : [
+            ...this.routingHistory
+        ];
+    }
+    /**
+   * Clear coordinator state
+   */ clear() {
+        this.activeRequests.clear();
+        this.requestQueue = [];
+        this.routingHistory = [];
+        this.matcher.clear();
+        this.recentLatencies = [];
+        this.requestCounter = 0;
+        this.metrics = {
+            totalRequests: 0,
+            successfulRoutes: 0,
+            failedRoutes: 0,
+            averageRoutingLatencyMs: 0,
+            p95RoutingLatencyMs: 0,
+            p99RoutingLatencyMs: 0,
+            activeRequests: 0,
+            queuedRequests: 0,
+            resolvedRequests: 0,
+            expiredRequests: 0
+        };
+    }
+    // ============================================
+    // MessageBroker Event Publishing
+    // ============================================
+    /**
+   * Publish routing event to MessageBroker
+   */ async publishRoutingEvent(result) {
+        if (!this.config.enableEventPublishing || !this.config.messageBroker) {
+            return;
+        }
+        try {
+            await this.config.messageBroker.publish({
+                topic: 'help.event.routed',
+                payload: {
+                    routingId: result.routingId,
+                    requestId: result.request.requestId,
+                    requesterId: result.request.requesterId,
+                    status: result.status,
+                    latencyMs: result.latencyMs,
+                    match: result.match ? {
+                        agentId: result.match.agentId,
+                        score: result.match.score
+                    } : null,
+                    timestamp: result.timestamp
+                },
+                priority: MessagePriority.LOW
+            });
+        } catch (error) {
+            console.error('[HelpCoordinator] Error publishing routing event:', error);
+        }
+    }
+    /**
+   * Publish help started event to MessageBroker
+   */ async publishHelpStartedEvent(request) {
+        if (!this.config.enableEventPublishing || !this.config.messageBroker) {
+            return;
+        }
+        try {
+            await this.config.messageBroker.publish({
+                topic: `help.accepted.${request.requestId}`,
+                payload: {
+                    requestId: request.requestId,
+                    helperId: request.matchedHelperId,
+                    timestamp: new Date()
+                },
+                priority: MessagePriority.HIGH
+            });
+        } catch (error) {
+            console.error('[HelpCoordinator] Error publishing help started event:', error);
+        }
+    }
+    /**
+   * Publish help resolved event to MessageBroker
+   */ async publishHelpResolvedEvent(request, metadata) {
+        if (!this.config.enableEventPublishing || !this.config.messageBroker) {
+            return;
+        }
+        try {
+            await this.config.messageBroker.publish({
+                topic: `help.completed.${request.requestId}`,
+                payload: {
+                    requestId: request.requestId,
+                    helperId: request.matchedHelperId,
+                    success: true,
+                    result: metadata,
+                    timestamp: new Date()
+                },
+                priority: MessagePriority.HIGH
+            });
+        } catch (error) {
+            console.error('[HelpCoordinator] Error publishing help resolved event:', error);
+        }
+    }
+    /**
+   * Publish help failed event to MessageBroker
+   */ async publishHelpFailedEvent(request, reason, metadata) {
+        if (!this.config.enableEventPublishing || !this.config.messageBroker) {
+            return;
+        }
+        try {
+            await this.config.messageBroker.publish({
+                topic: `help.completed.${request.requestId}`,
+                payload: {
+                    requestId: request.requestId,
+                    helperId: request.matchedHelperId,
+                    success: false,
+                    error: reason,
+                    timestamp: new Date()
+                },
+                priority: MessagePriority.HIGH
+            });
+        } catch (error) {
+            console.error('[HelpCoordinator] Error publishing help failed event:', error);
+        }
+    }
+}
+
+//# sourceMappingURL=help-coordinator.js.map