genesis-ai-cli 7.4.8 → 7.5.1

package/dist/src/mcp/multimodal.js

@@ -0,0 +1,355 @@
+"use strict";
+/**
+ * Genesis MCP Multimodal Handler
+ *
+ * Handles image, audio, and other media types from MCP tool results.
+ * Provides terminal display, file management, and format conversion.
+ *
+ * Features:
+ * - Detect media in tool results
+ * - Display images in terminal (iTerm2, Kitty, sixel)
+ * - Open media with system default apps
+ * - Convert between formats
+ * - Thumbnail generation
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultimodalHandler = void 0;
+exports.detectMediaType = detectMediaType;
+exports.extractMediaFromResult = extractMediaFromResult;
+exports.detectTerminalProtocol = detectTerminalProtocol;
+exports.displayImageInline = displayImageInline;
+exports.openWithSystemViewer = openWithSystemViewer;
+exports.getMultimodalHandler = getMultimodalHandler;
+exports.handleMultimodalResult = handleMultimodalResult;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// ============================================================================
+// Media Detection
+// ============================================================================
+const MIME_TYPE_MAP = {
+    'image/png': 'image',
+    'image/jpeg': 'image',
+    'image/gif': 'image',
+    'image/webp': 'image',
+    'image/svg+xml': 'image',
+    'audio/mpeg': 'audio',
+    'audio/wav': 'audio',
+    'audio/ogg': 'audio',
+    'video/mp4': 'video',
+    'video/webm': 'video',
+    'application/pdf': 'document',
+};
+const EXTENSION_MAP = {
+    '.png': 'image',
+    '.jpg': 'image',
+    '.jpeg': 'image',
+    '.gif': 'image',
+    '.webp': 'image',
+    '.svg': 'image',
+    '.mp3': 'audio',
+    '.wav': 'audio',
+    '.ogg': 'audio',
+    '.mp4': 'video',
+    '.webm': 'video',
+    '.pdf': 'document',
+};
+function detectMediaType(input) {
+    if (typeof input !== 'string') {
+        return input.type;
+    }
+    // Check extension
+    const ext = path.extname(input).toLowerCase();
+    if (EXTENSION_MAP[ext]) {
+        return EXTENSION_MAP[ext];
+    }
+    // Check if it's a data URL
+    if (input.startsWith('data:')) {
+        const mimeMatch = input.match(/^data:([^;,]+)/);
+        if (mimeMatch && MIME_TYPE_MAP[mimeMatch[1]]) {
+            return MIME_TYPE_MAP[mimeMatch[1]];
+        }
+    }
+    return 'unknown';
+}
+function extractMediaFromResult(result) {
+    const media = [];
+    if (!result)
+        return media;
+    // Check for common image result patterns
+    const imagePatterns = [
+        'imagePath', 'outputPath', 'path', 'filePath', 'file_path',
+        'imageUrl', 'url', 'src', 'image', 'output',
+    ];
+    for (const pattern of imagePatterns) {
+        if (result[pattern] && typeof result[pattern] === 'string') {
+            const value = result[pattern];
+            const type = detectMediaType(value);
+            if (type !== 'unknown') {
+                media.push({
+                    type,
+                    mimeType: getMimeType(value),
+                    path: value.startsWith('/') || value.startsWith('.') ? value : undefined,
+                    url: value.startsWith('http') ? value : undefined,
+                    base64: value.startsWith('data:') ? value.split(',')[1] : undefined,
+                });
+            }
+        }
+    }
+    // Check for base64 data
+    if (result.base64 || result.data) {
+        const base64Data = result.base64 || result.data;
+        if (typeof base64Data === 'string' && base64Data.length > 100) {
+            media.push({
+                type: 'image',
+                mimeType: result.mimeType || 'image/png',
+                base64: base64Data,
+            });
+        }
+    }
+    // Check for arrays of results
+    if (Array.isArray(result.images || result.files || result.outputs)) {
+        const items = result.images || result.files || result.outputs;
+        for (const item of items) {
+            media.push(...extractMediaFromResult(item));
+        }
+    }
+    return media;
+}
+function getMimeType(pathOrUrl) {
+    const ext = path.extname(pathOrUrl).toLowerCase();
+    const mimeMap = {
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.svg': 'image/svg+xml',
+        '.mp3': 'audio/mpeg',
+        '.wav': 'audio/wav',
+        '.mp4': 'video/mp4',
+        '.pdf': 'application/pdf',
+    };
+    return mimeMap[ext] || 'application/octet-stream';
+}
+// ============================================================================
+// Terminal Display
+// ============================================================================
+function detectTerminalProtocol() {
+    const term = process.env.TERM_PROGRAM || '';
+    const termEnv = process.env.TERM || '';
+    if (term === 'iTerm.app') {
+        return 'iterm2';
+    }
+    if (term === 'kitty' || termEnv.includes('kitty')) {
+        return 'kitty';
+    }
+    if (termEnv.includes('xterm') && process.env.SIXEL_SUPPORT === 'true') {
+        return 'sixel';
+    }
+    // Fallback to ASCII art representation
+    return 'ascii';
+}
+async function displayImageInline(imagePath, options = {}) {
+    const protocol = options.protocol || detectTerminalProtocol();
+    try {
+        switch (protocol) {
+            case 'iterm2':
+                return await displayITerm2(imagePath, options);
+            case 'kitty':
+                return await displayKitty(imagePath, options);
+            case 'sixel':
+                return await displaySixel(imagePath, options);
+            case 'ascii':
+                return await displayAscii(imagePath, options);
+            default:
+                return false;
+        }
+    }
+    catch (error) {
+        console.error(`[Multimodal] Display error: ${error}`);
+        return false;
+    }
+}
+async function displayITerm2(imagePath, options) {
+    try {
+        const data = await fs.promises.readFile(imagePath);
+        const base64 = data.toString('base64');
+        const width = options.maxWidth || 80;
+        const height = options.maxHeight || 24;
+        // iTerm2 inline image protocol
+        const osc = '\x1b]1337;File=';
+        const params = `inline=1;width=${width};height=${height};preserveAspectRatio=1`;
+        const st = '\x07';
+        process.stdout.write(`${osc}${params}:${base64}${st}\n`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function displayKitty(imagePath, options) {
+    try {
+        // Use kitten icat for Kitty terminal
+        await execAsync(`kitten icat --place ${options.maxWidth || 80}x${options.maxHeight || 24}@0x0 "${imagePath}"`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function displaySixel(imagePath, options) {
+    try {
+        // Use img2sixel if available
+        await execAsync(`img2sixel -w ${options.maxWidth || 800} "${imagePath}"`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function displayAscii(imagePath, options) {
+    try {
+        // Generate simple ASCII representation using file info
+        const stats = await fs.promises.stat(imagePath);
+        const ext = path.extname(imagePath);
+        const name = path.basename(imagePath);
+        console.log('┌─────────────────────────────────────┐');
+        console.log(`│ 🖼️  ${name.slice(0, 33).padEnd(33)} │`);
+        console.log(`│    Format: ${ext.slice(1).toUpperCase().padEnd(24)} │`);
+        console.log(`│    Size: ${formatBytes(stats.size).padEnd(26)} │`);
+        console.log(`│    Path: ...${imagePath.slice(-22).padEnd(23)} │`);
+        console.log('└─────────────────────────────────────┘');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+// ============================================================================
+// System Viewer
+// ============================================================================
+async function openWithSystemViewer(filePath) {
+    const platform = process.platform;
+    try {
+        let command;
+        switch (platform) {
+            case 'darwin':
+                command = 'open';
+                break;
+            case 'win32':
+                command = 'start';
+                break;
+            default:
+                command = 'xdg-open';
+        }
+        await execAsync(`${command} "${filePath}"`);
+        return true;
+    }
+    catch (error) {
+        console.error(`[Multimodal] Failed to open: ${error}`);
+        return false;
+    }
+}
+// ============================================================================
+// Main Handler
+// ============================================================================
+class MultimodalHandler {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            maxWidth: 80,
+            maxHeight: 24,
+            autoOpen: false,
+            inline: true,
+            protocol: detectTerminalProtocol(),
+            ...options,
+        };
+    }
+    async handleResult(result) {
+        const media = extractMediaFromResult(result);
+        const multimodalResult = {
+            detected: media.length > 0,
+            media,
+            displayedInline: false,
+            openedExternally: false,
+        };
+        if (media.length === 0) {
+            return multimodalResult;
+        }
+        for (const item of media) {
+            if (item.type === 'image' && item.path) {
+                // Try inline display
+                if (this.options.inline) {
+                    const displayed = await displayImageInline(item.path, this.options);
+                    multimodalResult.displayedInline = multimodalResult.displayedInline || displayed;
+                }
+                // Auto-open if configured
+                if (this.options.autoOpen) {
+                    const opened = await openWithSystemViewer(item.path);
+                    multimodalResult.openedExternally = multimodalResult.openedExternally || opened;
+                }
+            }
+        }
+        return multimodalResult;
+    }
+    setOptions(options) {
+        Object.assign(this.options, options);
+    }
+}
+exports.MultimodalHandler = MultimodalHandler;
+// ============================================================================
+// Singleton
+// ============================================================================
+let handlerInstance = null;
+function getMultimodalHandler(options) {
+    if (!handlerInstance) {
+        handlerInstance = new MultimodalHandler(options);
+    }
+    return handlerInstance;
+}
+async function handleMultimodalResult(result) {
+    return getMultimodalHandler().handleResult(result);
+}

package/dist/src/mcp/parallel-executor.d.ts

@@ -0,0 +1,113 @@
+/**
+ * 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
+ */
+import { MCPServerName } from '../types.js';
+import { MCPCallResult } from './index.js';
+export interface DAGNode {
+    id: string;
+    server: MCPServerName;
+    tool: string;
+    params: Record<string, any> | ((results: Map<string, any>) => Record<string, any>);
+    dependsOn: string[];
+    priority?: number;
+    timeout?: number;
+}
+export interface DAGExecutionResult {
+    success: boolean;
+    results: Map<string, MCPCallResult>;
+    errors: Map<string, Error>;
+    executionOrder: string[][];
+    totalLatency: number;
+    parallelismAchieved: number;
+}
+export interface DAGVisualization {
+    nodes: Array<{
+        id: string;
+        level: number;
+        dependsOn: string[];
+        status: 'pending' | 'running' | 'completed' | 'failed';
+    }>;
+    levels: number;
+    criticalPath: string[];
+}
+export declare class ParallelDAGExecutor {
+    private mcpClient;
+    private maxConcurrency;
+    constructor(maxConcurrency?: number);
+    /**
+     * Execute a DAG of MCP calls with maximum parallelism
+     */
+    execute(nodes: DAGNode[]): Promise<DAGExecutionResult>;
+    /**
+     * Execute a single node
+     */
+    private executeNode;
+    /**
+     * Build execution levels via topological sort
+     */
+    private buildExecutionLevels;
+    /**
+     * Detect cycles using DFS
+     */
+    private detectCycles;
+    /**
+     * Get visualization of DAG structure
+     */
+    visualize(nodes: DAGNode[]): DAGVisualization;
+    /**
+     * Find the critical path (longest dependency chain)
+     */
+    private findCriticalPath;
+    private chunkArray;
+}
+export declare class DAGBuilder {
+    private nodes;
+    /**
+     * Add a node to the DAG
+     */
+    node(id: string, server: MCPServerName, tool: string, params: DAGNode['params'], options?: {
+        dependsOn?: string[];
+        priority?: number;
+        timeout?: number;
+    }): DAGBuilder;
+    /**
+     * Add dependency between nodes
+     */
+    depend(nodeId: string, ...dependsOnIds: string[]): DAGBuilder;
+    /**
+     * Build and return the nodes
+     */
+    build(): DAGNode[];
+    /**
+     * Execute the DAG
+     */
+    execute(): Promise<DAGExecutionResult>;
+}
+export declare function getDAGExecutor(maxConcurrency?: number): ParallelDAGExecutor;
+export declare function dag(): DAGBuilder;
+/**
+ * Quick parallel execution of independent calls
+ */
+export declare function parallel(calls: Array<{
+    server: MCPServerName;
+    tool: string;
+    params: Record<string, any>;
+}>): Promise<MCPCallResult[]>;
+/**
+ * Sequential execution with result passing
+ */
+export declare function sequential(calls: Array<{
+    server: MCPServerName;
+    tool: string;
+    params: Record<string, any> | ((prev: any) => Record<string, any>);
+}>): Promise<MCPCallResult[]>;