genesis-ai-cli 7.4.7 → 7.5.0

package/dist/src/mcp/parallel-executor.js

@@ -0,0 +1,335 @@
+"use strict";
+/**
+ * Genesis MCP Parallel DAG Executor
+ *
+ * Dependency-aware parallel execution of MCP tool calls.
+ * Analyzes call dependencies and maximizes parallelism.
+ *
+ * Features:
+ * - Automatic dependency detection
+ * - Topological sort for execution order
+ * - Maximum parallelism within dependency constraints
+ * - Execution visualization
+ * - Cycle detection
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAGBuilder = exports.ParallelDAGExecutor = void 0;
+exports.getDAGExecutor = getDAGExecutor;
+exports.dag = dag;
+exports.parallel = parallel;
+exports.sequential = sequential;
+const index_js_1 = require("./index.js");
+// ============================================================================
+// DAG Executor
+// ============================================================================
+class ParallelDAGExecutor {
+    mcpClient = (0, index_js_1.getMCPClient)();
+    maxConcurrency;
+    constructor(maxConcurrency = 10) {
+        this.maxConcurrency = maxConcurrency;
+    }
+    /**
+     * Execute a DAG of MCP calls with maximum parallelism
+     */
+    async execute(nodes) {
+        const startTime = Date.now();
+        const results = new Map();
+        const errors = new Map();
+        const executionOrder = [];
+        // Validate DAG (check for cycles)
+        this.detectCycles(nodes);
+        // Build execution levels (topological sort)
+        const levels = this.buildExecutionLevels(nodes);
+        let totalParallel = 0;
+        // Execute level by level
+        for (const level of levels) {
+            const batch = [];
+            // Execute nodes at this level in parallel (respecting max concurrency)
+            const chunks = this.chunkArray(level, this.maxConcurrency);
+            for (const chunk of chunks) {
+                const promises = chunk.map(async (node) => {
+                    try {
+                        // Resolve params if they're functions
+                        const params = typeof node.params === 'function'
+                            ? node.params(results)
+                            : node.params;
+                        const result = await this.executeNode(node, params);
+                        results.set(node.id, result);
+                        if (!result.success) {
+                            errors.set(node.id, new Error(result.error || 'Unknown error'));
+                        }
+                    }
+                    catch (error) {
+                        const err = error instanceof Error ? error : new Error(String(error));
+                        errors.set(node.id, err);
+                        results.set(node.id, {
+                            success: false,
+                            error: err.message,
+                            server: node.server,
+                            tool: node.tool,
+                            mode: 'real',
+                            latency: 0,
+                            timestamp: new Date(),
+                        });
+                    }
+                });
+                await Promise.all(promises);
+                batch.push(...chunk.map(n => n.id));
+                totalParallel += chunk.length;
+            }
+            executionOrder.push(batch);
+        }
+        const totalLatency = Date.now() - startTime;
+        const parallelismAchieved = totalParallel / executionOrder.length;
+        return {
+            success: errors.size === 0,
+            results,
+            errors,
+            executionOrder,
+            totalLatency,
+            parallelismAchieved,
+        };
+    }
+    /**
+     * Execute a single node
+     */
+    async executeNode(node, params) {
+        if (node.timeout) {
+            return Promise.race([
+                this.mcpClient.call(node.server, node.tool, params),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), node.timeout)),
+            ]);
+        }
+        return this.mcpClient.call(node.server, node.tool, params);
+    }
+    /**
+     * Build execution levels via topological sort
+     */
+    buildExecutionLevels(nodes) {
+        const nodeMap = new Map(nodes.map(n => [n.id, n]));
+        const inDegree = new Map();
+        const levels = [];
+        // Calculate in-degrees
+        for (const node of nodes) {
+            inDegree.set(node.id, node.dependsOn.length);
+        }
+        // Process level by level
+        while (inDegree.size > 0) {
+            // Find all nodes with no remaining dependencies
+            const readyNodes = [];
+            for (const [id, degree] of inDegree) {
+                if (degree === 0) {
+                    readyNodes.push(nodeMap.get(id));
+                }
+            }
+            if (readyNodes.length === 0 && inDegree.size > 0) {
+                throw new Error('Cycle detected in DAG');
+            }
+            // Sort by priority within level
+            readyNodes.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+            levels.push(readyNodes);
+            // Remove processed nodes and update dependencies
+            for (const node of readyNodes) {
+                inDegree.delete(node.id);
+                // Decrease in-degree of dependents
+                for (const otherNode of nodes) {
+                    if (otherNode.dependsOn.includes(node.id)) {
+                        inDegree.set(otherNode.id, (inDegree.get(otherNode.id) || 0) - 1);
+                    }
+                }
+            }
+        }
+        return levels;
+    }
+    /**
+     * Detect cycles using DFS
+     */
+    detectCycles(nodes) {
+        const nodeMap = new Map(nodes.map(n => [n.id, n]));
+        const visited = new Set();
+        const recursionStack = new Set();
+        const dfs = (nodeId) => {
+            visited.add(nodeId);
+            recursionStack.add(nodeId);
+            const node = nodeMap.get(nodeId);
+            if (node) {
+                for (const depId of node.dependsOn) {
+                    if (!visited.has(depId)) {
+                        if (dfs(depId))
+                            return true;
+                    }
+                    else if (recursionStack.has(depId)) {
+                        return true; // Cycle found
+                    }
+                }
+            }
+            recursionStack.delete(nodeId);
+            return false;
+        };
+        for (const node of nodes) {
+            if (!visited.has(node.id)) {
+                if (dfs(node.id)) {
+                    throw new Error(`Cycle detected in DAG involving node: ${node.id}`);
+                }
+            }
+        }
+    }
+    /**
+     * Get visualization of DAG structure
+     */
+    visualize(nodes) {
+        const levels = this.buildExecutionLevels(nodes);
+        const nodeToLevel = new Map();
+        levels.forEach((level, idx) => {
+            level.forEach(node => nodeToLevel.set(node.id, idx));
+        });
+        // Find critical path (longest path)
+        const criticalPath = this.findCriticalPath(nodes, nodeToLevel);
+        return {
+            nodes: nodes.map(node => ({
+                id: node.id,
+                level: nodeToLevel.get(node.id) || 0,
+                dependsOn: node.dependsOn,
+                status: 'pending',
+            })),
+            levels: levels.length,
+            criticalPath,
+        };
+    }
+    /**
+     * Find the critical path (longest dependency chain)
+     */
+    findCriticalPath(nodes, nodeToLevel) {
+        const nodeMap = new Map(nodes.map(n => [n.id, n]));
+        let longestPath = [];
+        const findPath = (nodeId, currentPath) => {
+            const node = nodeMap.get(nodeId);
+            if (!node)
+                return;
+            currentPath.push(nodeId);
+            if (node.dependsOn.length === 0) {
+                // Reached a root node
+                if (currentPath.length > longestPath.length) {
+                    longestPath = [...currentPath];
+                }
+            }
+            else {
+                for (const depId of node.dependsOn) {
+                    findPath(depId, currentPath);
+                }
+            }
+            currentPath.pop();
+        };
+        // Find leaf nodes (nodes that nothing depends on)
+        const hasDependent = new Set();
+        for (const node of nodes) {
+            for (const depId of node.dependsOn) {
+                hasDependent.add(depId);
+            }
+        }
+        const leaves = nodes.filter(n => !hasDependent.has(n.id));
+        for (const leaf of leaves) {
+            findPath(leaf.id, []);
+        }
+        return longestPath.reverse();
+    }
+    chunkArray(array, size) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += size) {
+            chunks.push(array.slice(i, i + size));
+        }
+        return chunks;
+    }
+}
+exports.ParallelDAGExecutor = ParallelDAGExecutor;
+// ============================================================================
+// DAG Builder (Fluent API)
+// ============================================================================
+class DAGBuilder {
+    nodes = [];
+    /**
+     * Add a node to the DAG
+     */
+    node(id, server, tool, params, options = {}) {
+        this.nodes.push({
+            id,
+            server,
+            tool,
+            params,
+            dependsOn: options.dependsOn || [],
+            priority: options.priority,
+            timeout: options.timeout,
+        });
+        return this;
+    }
+    /**
+     * Add dependency between nodes
+     */
+    depend(nodeId, ...dependsOnIds) {
+        const node = this.nodes.find(n => n.id === nodeId);
+        if (node) {
+            node.dependsOn.push(...dependsOnIds);
+        }
+        return this;
+    }
+    /**
+     * Build and return the nodes
+     */
+    build() {
+        return this.nodes;
+    }
+    /**
+     * Execute the DAG
+     */
+    async execute() {
+        const executor = getDAGExecutor();
+        return executor.execute(this.nodes);
+    }
+}
+exports.DAGBuilder = DAGBuilder;
+// ============================================================================
+// Singleton & Utilities
+// ============================================================================
+let executorInstance = null;
+function getDAGExecutor(maxConcurrency) {
+    if (!executorInstance) {
+        executorInstance = new ParallelDAGExecutor(maxConcurrency);
+    }
+    return executorInstance;
+}
+function dag() {
+    return new DAGBuilder();
+}
+/**
+ * Quick parallel execution of independent calls
+ */
+async function parallel(calls) {
+    const nodes = calls.map((call, i) => ({
+        id: `call-${i}`,
+        server: call.server,
+        tool: call.tool,
+        params: call.params,
+        dependsOn: [],
+    }));
+    const result = await getDAGExecutor().execute(nodes);
+    return Array.from(result.results.values());
+}
+/**
+ * Sequential execution with result passing
+ */
+async function sequential(calls) {
+    const nodes = calls.map((call, i) => ({
+        id: `call-${i}`,
+        server: call.server,
+        tool: call.tool,
+        params: typeof call.params === 'function'
+            ? (results) => {
+                const prevResult = i > 0 ? results.get(`call-${i - 1}`)?.data : undefined;
+                return call.params(prevResult);
+            }
+            : call.params,
+        dependsOn: i > 0 ? [`call-${i - 1}`] : [],
+    }));
+    const result = await getDAGExecutor().execute(nodes);
+    return Array.from(result.results.values());
+}

package/dist/src/mcp/streaming.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Genesis MCP Streaming Results
+ *
+ * Real-time streaming of tool results with progress updates.
+ * Enables live feedback during long-running operations.
+ *
+ * Features:
+ * - Async iterator for results
+ * - Progress events (started, progress, chunk, complete, error)
+ * - Timeout handling with partial results
+ * - Buffered vs unbuffered modes
+ * - Event emitter integration
+ */
+import { EventEmitter } from 'events';
+import { MCPServerName } from '../types.js';
+import { MCPCallResult } from './index.js';
+export type StreamEventType = 'started' | 'progress' | 'chunk' | 'complete' | 'error' | 'timeout';
+export interface StreamEvent<T = any> {
+    type: StreamEventType;
+    server: MCPServerName;
+    tool: string;
+    timestamp: Date;
+    data?: T;
+    progress?: number;
+    error?: Error;
+    latency?: number;
+}
+export interface StreamOptions {
+    progressInterval?: number;
+    timeout?: number;
+    bufferSize?: number;
+    partialOnTimeout?: boolean;
+}
+export interface StreamableResult<T = any> {
+    promise: Promise<MCPCallResult<T>>;
+    events: EventEmitter;
+    [Symbol.asyncIterator](): AsyncIterator<StreamEvent<T>>;
+    cancel(): void;
+    isRunning(): boolean;
+}
+export declare class StreamingMCPWrapper extends EventEmitter {
+    private mcpClient;
+    private activeStreams;
+    /**
+     * Call an MCP tool with streaming support
+     */
+    callStreaming<T = any>(server: MCPServerName, tool: string, params: Record<string, any>, options?: StreamOptions): StreamableResult<T>;
+    /**
+     * Call multiple tools with merged streaming
+     */
+    callParallelStreaming<T = any>(calls: Array<{
+        server: MCPServerName;
+        tool: string;
+        params: Record<string, any>;
+    }>, options?: StreamOptions): StreamableResult<T[]>;
+    /**
+     * Get count of active streams
+     */
+    getActiveStreamCount(): number;
+    /**
+     * Cancel all active streams
+     */
+    cancelAll(): void;
+}
+export declare class ProgressReporter {
+    private startTime;
+    private lastUpdate;
+    private spinner;
+    private spinnerIndex;
+    start(label: string): void;
+    update(progress?: number): void;
+    complete(label: string): void;
+    error(label: string): void;
+    private getSpinner;
+    private formatTime;
+}
+export declare function getStreamingWrapper(): StreamingMCPWrapper;
+export declare function callStreaming<T = any>(server: MCPServerName, tool: string, params: Record<string, any>, options?: StreamOptions): StreamableResult<T>;