genesis-ai-cli 7.4.8 → 7.5.1

package/dist/src/mcp/streaming.js

@@ -0,0 +1,345 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressReporter = exports.StreamingMCPWrapper = void 0;
+exports.getStreamingWrapper = getStreamingWrapper;
+exports.callStreaming = callStreaming;
+const events_1 = require("events");
+const index_js_1 = require("./index.js");
+// ============================================================================
+// Streaming Wrapper
+// ============================================================================
+class StreamingMCPWrapper extends events_1.EventEmitter {
+    mcpClient = (0, index_js_1.getMCPClient)();
+    activeStreams = new Map();
+    /**
+     * Call an MCP tool with streaming support
+     */
+    callStreaming(server, tool, params, options = {}) {
+        const streamId = `${server}.${tool}.${Date.now()}`;
+        const controller = new AbortController();
+        const startTime = Date.now();
+        this.activeStreams.set(streamId, { controller, startTime });
+        const events = new events_1.EventEmitter();
+        let cancelled = false;
+        let completed = false;
+        const chunks = [];
+        // Emit started event
+        const startEvent = {
+            type: 'started',
+            server,
+            tool,
+            timestamp: new Date(),
+        };
+        events.emit('started', startEvent);
+        this.emit('stream:started', startEvent);
+        // Set up progress interval
+        let progressInterval;
+        if (options.progressInterval) {
+            let progressCount = 0;
+            progressInterval = setInterval(() => {
+                if (!completed && !cancelled) {
+                    progressCount++;
+                    const progressEvent = {
+                        type: 'progress',
+                        server,
+                        tool,
+                        timestamp: new Date(),
+                        progress: Math.min(95, progressCount * 10), // Synthetic progress
+                        latency: Date.now() - startTime,
+                    };
+                    events.emit('progress', progressEvent);
+                    this.emit('stream:progress', progressEvent);
+                }
+            }, options.progressInterval);
+        }
+        // Set up timeout
+        let timeoutHandle;
+        if (options.timeout) {
+            timeoutHandle = setTimeout(() => {
+                if (!completed) {
+                    cancelled = true;
+                    controller.abort();
+                    const timeoutEvent = {
+                        type: 'timeout',
+                        server,
+                        tool,
+                        timestamp: new Date(),
+                        latency: Date.now() - startTime,
+                        data: options.partialOnTimeout && chunks.length > 0 ? chunks[chunks.length - 1] : undefined,
+                    };
+                    events.emit('timeout', timeoutEvent);
+                    this.emit('stream:timeout', timeoutEvent);
+                }
+            }, options.timeout);
+        }
+        // Execute the call
+        const promise = (async () => {
+            try {
+                const result = await this.mcpClient.call(server, tool, params);
+                if (cancelled) {
+                    throw new Error('Stream cancelled');
+                }
+                completed = true;
+                // Emit chunk for the result
+                const chunkEvent = {
+                    type: 'chunk',
+                    server,
+                    tool,
+                    timestamp: new Date(),
+                    data: result.data,
+                    latency: Date.now() - startTime,
+                };
+                events.emit('chunk', chunkEvent);
+                this.emit('stream:chunk', chunkEvent);
+                if (result.data) {
+                    chunks.push(result.data);
+                }
+                // Emit complete event
+                const completeEvent = {
+                    type: 'complete',
+                    server,
+                    tool,
+                    timestamp: new Date(),
+                    data: result.data,
+                    progress: 100,
+                    latency: Date.now() - startTime,
+                };
+                events.emit('complete', completeEvent);
+                this.emit('stream:complete', completeEvent);
+                return result;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                const errorEvent = {
+                    type: 'error',
+                    server,
+                    tool,
+                    timestamp: new Date(),
+                    error: err,
+                    latency: Date.now() - startTime,
+                };
+                events.emit('error', errorEvent);
+                this.emit('stream:error', errorEvent);
+                return {
+                    success: false,
+                    error: err.message,
+                    server,
+                    tool,
+                    mode: 'real',
+                    latency: Date.now() - startTime,
+                    timestamp: new Date(),
+                };
+            }
+            finally {
+                // Cleanup
+                if (progressInterval)
+                    clearInterval(progressInterval);
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                this.activeStreams.delete(streamId);
+            }
+        })();
+        // Create async iterator
+        const asyncIterator = async function* () {
+            const queue = [];
+            let resolveNext = null;
+            let done = false;
+            const push = (event) => {
+                if (resolveNext) {
+                    resolveNext({ value: event, done: false });
+                    resolveNext = null;
+                }
+                else {
+                    queue.push(event);
+                }
+            };
+            events.on('started', push);
+            events.on('progress', push);
+            events.on('chunk', push);
+            events.on('complete', (e) => {
+                push(e);
+                done = true;
+            });
+            events.on('error', (e) => {
+                push(e);
+                done = true;
+            });
+            events.on('timeout', (e) => {
+                push(e);
+                done = true;
+            });
+            while (!done || queue.length > 0) {
+                if (queue.length > 0) {
+                    yield queue.shift();
+                }
+                else {
+                    const event = await new Promise((resolve) => {
+                        resolveNext = (result) => resolve(result.value);
+                    });
+                    yield event;
+                }
+            }
+        };
+        return {
+            promise,
+            events,
+            [Symbol.asyncIterator]: asyncIterator,
+            cancel: () => {
+                cancelled = true;
+                controller.abort();
+            },
+            isRunning: () => !completed && !cancelled,
+        };
+    }
+    /**
+     * Call multiple tools with merged streaming
+     */
+    callParallelStreaming(calls, options = {}) {
+        const events = new events_1.EventEmitter();
+        const results = [];
+        let completedCount = 0;
+        let cancelled = false;
+        const startTime = Date.now();
+        const streams = calls.map((call) => this.callStreaming(call.server, call.tool, call.params, options));
+        // Forward all events
+        for (let i = 0; i < streams.length; i++) {
+            const stream = streams[i];
+            stream.events.on('started', (e) => events.emit('started', { ...e, index: i }));
+            stream.events.on('progress', (e) => events.emit('progress', { ...e, index: i }));
+            stream.events.on('chunk', (e) => {
+                if (e.data)
+                    results[i] = e.data;
+                events.emit('chunk', { ...e, index: i });
+            });
+            stream.events.on('complete', (e) => {
+                completedCount++;
+                if (e.data)
+                    results[i] = e.data;
+                events.emit('progress', {
+                    ...e,
+                    index: i,
+                    progress: (completedCount / calls.length) * 100,
+                });
+                if (completedCount === calls.length) {
+                    events.emit('complete', {
+                        type: 'complete',
+                        server: 'parallel',
+                        tool: 'batch',
+                        timestamp: new Date(),
+                        data: results,
+                        progress: 100,
+                        latency: Date.now() - startTime,
+                    });
+                }
+            });
+            stream.events.on('error', (e) => events.emit('error', { ...e, index: i }));
+        }
+        const promise = Promise.all(streams.map((s) => s.promise)).then((allResults) => ({
+            success: allResults.every((r) => r.success),
+            data: allResults.map((r) => r.data),
+            server: 'parallel',
+            tool: 'batch',
+            mode: 'real',
+            latency: Date.now() - startTime,
+            timestamp: new Date(),
+        }));
+        const asyncIterator = async function* () {
+            for (const stream of streams) {
+                for await (const event of stream) {
+                    yield event;
+                }
+            }
+        };
+        return {
+            promise,
+            events,
+            [Symbol.asyncIterator]: asyncIterator,
+            cancel: () => {
+                cancelled = true;
+                streams.forEach((s) => s.cancel());
+            },
+            isRunning: () => !cancelled && completedCount < calls.length,
+        };
+    }
+    /**
+     * Get count of active streams
+     */
+    getActiveStreamCount() {
+        return this.activeStreams.size;
+    }
+    /**
+     * Cancel all active streams
+     */
+    cancelAll() {
+        for (const [id, { controller }] of this.activeStreams) {
+            controller.abort();
+        }
+        this.activeStreams.clear();
+    }
+}
+exports.StreamingMCPWrapper = StreamingMCPWrapper;
+// ============================================================================
+// Progress Reporter
+// ============================================================================
+class ProgressReporter {
+    startTime = 0;
+    lastUpdate = 0;
+    spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    spinnerIndex = 0;
+    start(label) {
+        this.startTime = Date.now();
+        this.lastUpdate = this.startTime;
+        process.stdout.write(`${this.getSpinner()} ${label}...`);
+    }
+    update(progress) {
+        const elapsed = Date.now() - this.startTime;
+        const progressStr = progress !== undefined ? ` ${progress.toFixed(0)}%` : '';
+        process.stdout.write(`\r${this.getSpinner()} Working...${progressStr} (${this.formatTime(elapsed)})`);
+    }
+    complete(label) {
+        const elapsed = Date.now() - this.startTime;
+        process.stdout.write(`\r✓ ${label} (${this.formatTime(elapsed)})\n`);
+    }
+    error(label) {
+        const elapsed = Date.now() - this.startTime;
+        process.stdout.write(`\r✗ ${label} (${this.formatTime(elapsed)})\n`);
+    }
+    getSpinner() {
+        this.spinnerIndex = (this.spinnerIndex + 1) % this.spinner.length;
+        return this.spinner[this.spinnerIndex];
+    }
+    formatTime(ms) {
+        if (ms < 1000)
+            return `${ms}ms`;
+        if (ms < 60000)
+            return `${(ms / 1000).toFixed(1)}s`;
+        return `${(ms / 60000).toFixed(1)}m`;
+    }
+}
+exports.ProgressReporter = ProgressReporter;
+// ============================================================================
+// Singleton
+// ============================================================================
+let streamingInstance = null;
+function getStreamingWrapper() {
+    if (!streamingInstance) {
+        streamingInstance = new StreamingMCPWrapper();
+    }
+    return streamingInstance;
+}
+function callStreaming(server, tool, params, options) {
+    return getStreamingWrapper().callStreaming(server, tool, params, options);
+}

package/dist/src/mcp/tool-chain.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Genesis MCP Tool Chaining Framework
+ *
+ * Automatic orchestration of dependent tool calls.
+ * Enables workflows like: generate image → open it → edit it
+ *
+ * Features:
+ * - Declarative chain definitions
+ * - Automatic output → input mapping
+ * - Conditional branching
+ * - Error recovery and rollback
+ * - Chain execution history
+ */
+import { MCPServerName } from '../types.js';
+export interface ChainStep {
+    id: string;
+    server: MCPServerName;
+    tool: string;
+    params: Record<string, any> | ((ctx: ChainContext) => Record<string, any>);
+    transform?: (result: any) => any;
+    condition?: (ctx: ChainContext) => boolean;
+    onError?: 'stop' | 'skip' | 'retry' | ((error: Error, ctx: ChainContext) => ChainStep | null);
+    maxRetries?: number;
+}
+export interface ChainDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    steps: ChainStep[];
+    initialContext?: Record<string, any>;
+    finalTransform?: (ctx: ChainContext) => any;
+}
+export interface ChainContext {
+    results: Map<string, any>;
+    currentStep: number;
+    errors: Array<{
+        stepId: string;
+        error: Error;
+    }>;
+    data: Record<string, any>;
+    startTime: Date;
+    log: ChainLogEntry[];
+}
+export interface ChainLogEntry {
+    timestamp: Date;
+    stepId: string;
+    action: 'start' | 'success' | 'error' | 'skip' | 'retry';
+    details?: any;
+    latency?: number;
+}
+export interface ChainResult {
+    success: boolean;
+    finalResult: any;
+    context: ChainContext;
+    totalLatency: number;
+    stepsExecuted: number;
+    stepsFailed: number;
+}
+export declare const CHAIN_TEMPLATES: Record<string, ChainDefinition>;
+export declare class ToolChainExecutor {
+    private mcpClient;
+    execute(chain: ChainDefinition, initialData?: Record<string, any>): Promise<ChainResult>;
+    private executeStep;
+    private retryStep;
+    private log;
+}
+export declare class ChainBuilder {
+    private chain;
+    constructor(id: string, name: string);
+    description(desc: string): ChainBuilder;
+    initialContext(ctx: Record<string, any>): ChainBuilder;
+    step(step: ChainStep): ChainBuilder;
+    call(id: string, server: MCPServerName, tool: string, params: ChainStep['params']): ChainBuilder;
+    finalTransform(fn: (ctx: ChainContext) => any): ChainBuilder;
+    build(): ChainDefinition;
+}
+export declare function getChainExecutor(): ToolChainExecutor;
+export declare function chain(id: string, name: string): ChainBuilder;
+export declare function executeChain(chainOrId: ChainDefinition | string, data?: Record<string, any>): Promise<ChainResult>;