genesis-ai-cli 7.4.7 → 7.5.0

package/dist/src/mcp/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Genesis 6.8 - Real MCP Client Module
+ * Genesis 7.5 - Real MCP Client Module
  *
  * Connects to actual MCP servers using @modelcontextprotocol/sdk.
  * Spawns servers on demand and manages connections.
@@ -9,6 +9,14 @@
  * - GENESIS_MCP_MODE: 'real' | 'simulated' | 'hybrid' (default: 'simulated')
  * - GENESIS_MCP_TIMEOUT: Timeout in ms (default: 30000)
  * - GENESIS_MCP_LOG: Enable MCP call logging (default: false)
+ *
+ * New in 7.5: Frontier MCP capabilities
+ * - Tool Chaining: Automatic orchestration of dependent tool calls
+ * - Streaming: Real-time result streaming with progress
+ * - Multimodal: Image/media display in terminal
+ * - Cache: Intelligent per-server caching with TTL
+ * - DAG Executor: Parallel execution with dependency awareness
+ * - Transformers: Composable result transformations
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -33,6 +41,13 @@ exports.isSimulatedResult = isSimulatedResult;
 exports.logMCPMode = logMCPMode;
 // Re-export Phase 8: Resilient MCP Wrapper
 __exportStar(require("./resilient.js"), exports);
+// Re-export Phase 10: Frontier MCP Capabilities
+__exportStar(require("./tool-chain.js"), exports);
+__exportStar(require("./streaming.js"), exports);
+__exportStar(require("./multimodal.js"), exports);
+__exportStar(require("./cache.js"), exports);
+__exportStar(require("./parallel-executor.js"), exports);
+__exportStar(require("./transformers.js"), exports);
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
 const crypto_1 = require("crypto");
@@ -77,7 +92,7 @@ const MCP_SERVER_REGISTRY = {
     'brave-search': {
         command: 'npx',
         args: () => ['-y', '@brave/brave-search-mcp-server', '--brave-api-key', process.env.BRAVE_API_KEY || ''],
-        tools: ['brave_web_search', 'brave_local_search', 'brave_news_search', 'brave_image_search', 'brave_video_search'],
+        tools: ['brave_web_search', 'brave_local_search', 'brave_news_search', 'brave_image_search', 'brave_video_search', 'brave_summarizer'],
     },
     'exa': {
         command: 'npx',
@@ -89,7 +104,7 @@ const MCP_SERVER_REGISTRY = {
         command: 'npx',
         args: ['-y', 'firecrawl-mcp'],
         envVars: () => ({ FIRECRAWL_API_KEY: process.env.FIRECRAWL_API_KEY || '' }),
-        tools: ['firecrawl_scrape', 'firecrawl_search', 'firecrawl_map', 'firecrawl_crawl', 'firecrawl_extract'],
+        tools: ['firecrawl_scrape', 'firecrawl_search', 'firecrawl_map', 'firecrawl_crawl', 'firecrawl_check_crawl_status', 'firecrawl_extract', 'firecrawl_agent', 'firecrawl_agent_status'],
     },
     // CREATION
     'openai': {
@@ -105,25 +120,40 @@ const MCP_SERVER_REGISTRY = {
         envVars: () => ({
             GITHUB_PERSONAL_ACCESS_TOKEN: process.env.GITHUB_PERSONAL_ACCESS_TOKEN || process.env.GITHUB_TOKEN || ''
         }),
-        tools: ['create_repository', 'search_repositories', 'create_issue', 'create_pull_request', 'get_file_contents'],
+        tools: [
+            'create_repository', 'search_repositories', 'create_issue', 'list_issues', 'get_issue', 'update_issue',
+            'add_issue_comment', 'create_pull_request', 'get_pull_request', 'list_pull_requests', 'merge_pull_request',
+            'get_pull_request_files', 'create_pull_request_review', 'get_file_contents', 'create_or_update_file',
+            'push_files', 'create_branch', 'list_commits', 'fork_repository', 'search_code', 'search_issues', 'search_users'
+        ],
     },
     // VISUAL
     'stability-ai': {
         command: 'npx',
         args: ['-y', 'mcp-server-stability-ai'],
         envVars: () => ({ STABILITY_AI_API_KEY: process.env.STABILITY_AI_API_KEY || '' }),
-        tools: ['stability-ai-generate-image', 'stability-ai-generate-image-sd35', 'stability-ai-0-list-resources'],
+        tools: [
+            'stability-ai-generate-image', 'stability-ai-generate-image-sd35', 'stability-ai-remove-background',
+            'stability-ai-outpaint', 'stability-ai-search-and-replace', 'stability-ai-upscale-fast',
+            'stability-ai-upscale-creative', 'stability-ai-control-sketch', 'stability-ai-0-list-resources',
+            'stability-ai-search-and-recolor', 'stability-ai-replace-background-and-relight',
+            'stability-ai-control-style', 'stability-ai-control-structure'
+        ],
     },
     // STORAGE
     'memory': {
         command: 'npx',
         args: ['-y', '@modelcontextprotocol/server-memory'],
-        tools: ['create_entities', 'create_relations', 'search_nodes', 'read_graph', 'add_observations'],
+        tools: ['create_entities', 'create_relations', 'add_observations', 'delete_entities', 'delete_relations', 'delete_observations', 'search_nodes', 'open_nodes', 'read_graph'],
     },
     'filesystem': {
         command: 'npx',
         args: () => ['-y', '@modelcontextprotocol/server-filesystem', process.env.HOME || '/tmp'],
-        tools: ['read_file', 'read_text_file', 'write_file', 'list_directory', 'search_files', 'create_directory'],
+        tools: [
+            'read_file', 'read_text_file', 'read_media_file', 'read_multiple_files', 'write_file', 'edit_file',
+            'create_directory', 'list_directory', 'list_directory_with_sizes', 'directory_tree',
+            'move_file', 'search_files', 'get_file_info', 'list_allowed_directories'
+        ],
     },
 };
 exports.MCP_SERVER_REGISTRY = MCP_SERVER_REGISTRY;

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

@@ -0,0 +1,52 @@
+/**
+ * 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
+ */
+export type MediaType = 'image' | 'audio' | 'video' | 'document' | 'unknown';
+export interface MediaInfo {
+    type: MediaType;
+    mimeType: string;
+    path?: string;
+    url?: string;
+    base64?: string;
+    width?: number;
+    height?: number;
+    size?: number;
+    format?: string;
+}
+export interface DisplayOptions {
+    maxWidth?: number;
+    maxHeight?: number;
+    autoOpen?: boolean;
+    inline?: boolean;
+    protocol?: TerminalProtocol;
+}
+export type TerminalProtocol = 'iterm2' | 'kitty' | 'sixel' | 'ascii' | 'none';
+export interface MultimodalResult {
+    detected: boolean;
+    media: MediaInfo[];
+    displayedInline: boolean;
+    openedExternally: boolean;
+}
+export declare function detectMediaType(input: string | MediaInfo): MediaType;
+export declare function extractMediaFromResult(result: any): MediaInfo[];
+export declare function detectTerminalProtocol(): TerminalProtocol;
+export declare function displayImageInline(imagePath: string, options?: DisplayOptions): Promise<boolean>;
+export declare function openWithSystemViewer(filePath: string): Promise<boolean>;
+export declare class MultimodalHandler {
+    private options;
+    constructor(options?: DisplayOptions);
+    handleResult(result: any): Promise<MultimodalResult>;
+    setOptions(options: Partial<DisplayOptions>): void;
+}
+export declare function getMultimodalHandler(options?: DisplayOptions): MultimodalHandler;
+export declare function handleMultimodalResult(result: any): Promise<MultimodalResult>;

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[]>;