genesis-ai-cli 7.4.8 → 7.5.1

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

@@ -0,0 +1,100 @@
+/**
+ * Genesis MCP Intelligent Cache
+ *
+ * Smart caching with per-server TTL, semantic deduplication,
+ * and LRU eviction.
+ *
+ * Features:
+ * - Per-server TTL configuration
+ * - Semantic key hashing (similar queries hit same cache)
+ * - LRU eviction with configurable max size
+ * - Cache statistics and monitoring
+ * - Invalidation patterns
+ * - Persistent cache option (filesystem)
+ */
+import { MCPServerName } from '../types.js';
+import { MCPCallResult } from './index.js';
+export interface CacheEntry<T = any> {
+    key: string;
+    data: T;
+    server: MCPServerName;
+    tool: string;
+    createdAt: number;
+    expiresAt: number;
+    hits: number;
+    size: number;
+}
+export interface CacheStats {
+    hits: number;
+    misses: number;
+    entries: number;
+    totalSize: number;
+    hitRate: number;
+    byServer: Record<MCPServerName, {
+        hits: number;
+        misses: number;
+        entries: number;
+    }>;
+}
+export interface CacheConfig {
+    maxEntries?: number;
+    maxSize?: number;
+    defaultTTL?: number;
+    serverTTL?: Partial<Record<MCPServerName, number>>;
+    persistent?: boolean;
+    persistPath?: string;
+    semanticKeys?: boolean;
+}
+export declare class MCPCache {
+    private cache;
+    private accessOrder;
+    private stats;
+    private config;
+    constructor(config?: CacheConfig);
+    /**
+     * Get cached result
+     */
+    get<T = any>(server: MCPServerName, tool: string, params: Record<string, any>): CacheEntry<T> | null;
+    /**
+     * Cache a result
+     */
+    set<T = any>(server: MCPServerName, tool: string, params: Record<string, any>, data: T): void;
+    /**
+     * Wrap an MCP call with caching
+     */
+    wrap<T = any>(server: MCPServerName, tool: string, params: Record<string, any>, fetcher: () => Promise<MCPCallResult<T>>): Promise<MCPCallResult<T>>;
+    /**
+     * Invalidate cache entries
+     */
+    invalidate(pattern: {
+        server?: MCPServerName;
+        tool?: string;
+        olderThan?: number;
+    }): number;
+    /**
+     * Clear entire cache
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Get cache entries for debugging
+     */
+    getEntries(): CacheEntry[];
+    private generateKey;
+    private normalizeParams;
+    private getTTL;
+    private estimateSize;
+    private updateAccessOrder;
+    private evictIfNeeded;
+    private delete;
+    private updateHitRate;
+    private loadFromDisk;
+    private persistEntry;
+    private clearDisk;
+}
+export declare function getMCPCache(config?: CacheConfig): MCPCache;
+export declare function resetMCPCache(): void;
+export declare function withCache<T = any>(server: MCPServerName, tool: string, params: Record<string, any>, fetcher: () => Promise<MCPCallResult<T>>): Promise<MCPCallResult<T>>;

package/dist/src/mcp/cache.js

@@ -0,0 +1,395 @@
+"use strict";
+/**
+ * Genesis MCP Intelligent Cache
+ *
+ * Smart caching with per-server TTL, semantic deduplication,
+ * and LRU eviction.
+ *
+ * Features:
+ * - Per-server TTL configuration
+ * - Semantic key hashing (similar queries hit same cache)
+ * - LRU eviction with configurable max size
+ * - Cache statistics and monitoring
+ * - Invalidation patterns
+ * - Persistent cache option (filesystem)
+ */
+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.MCPCache = void 0;
+exports.getMCPCache = getMCPCache;
+exports.resetMCPCache = resetMCPCache;
+exports.withCache = withCache;
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ============================================================================
+// Default TTLs per server
+// ============================================================================
+const DEFAULT_SERVER_TTL = {
+    // Knowledge (can be cached longer)
+    'arxiv': 1000 * 60 * 60 * 24, // 24 hours
+    'semantic-scholar': 1000 * 60 * 60 * 24, // 24 hours
+    'context7': 1000 * 60 * 60 * 12, // 12 hours
+    'wolfram': 1000 * 60 * 60, // 1 hour
+    // Research (moderate caching)
+    'gemini': 1000 * 60 * 30, // 30 minutes
+    'brave-search': 1000 * 60 * 15, // 15 minutes (search results change)
+    'exa': 1000 * 60 * 30, // 30 minutes
+    'firecrawl': 1000 * 60 * 60, // 1 hour (scraped content)
+    // Creation (no caching by default)
+    'openai': 0, // Don't cache AI responses
+    'github': 1000 * 60 * 5, // 5 minutes (repos can change)
+    // Visual (no caching)
+    'stability-ai': 0, // Don't cache generated images
+    // Storage (short cache)
+    'memory': 1000 * 60 * 5, // 5 minutes
+    'filesystem': 1000 * 60, // 1 minute
+};
+// ============================================================================
+// Cache Implementation
+// ============================================================================
+class MCPCache {
+    cache = new Map();
+    accessOrder = []; // For LRU
+    stats = {
+        hits: 0,
+        misses: 0,
+        entries: 0,
+        totalSize: 0,
+        hitRate: 0,
+        byServer: {},
+    };
+    config;
+    constructor(config = {}) {
+        this.config = {
+            maxEntries: config.maxEntries ?? 1000,
+            maxSize: config.maxSize ?? 50 * 1024 * 1024, // 50MB
+            defaultTTL: config.defaultTTL ?? 1000 * 60 * 30, // 30 minutes
+            serverTTL: { ...DEFAULT_SERVER_TTL, ...config.serverTTL },
+            persistent: config.persistent ?? false,
+            persistPath: config.persistPath ?? path.join(process.cwd(), '.genesis-cache'),
+            semanticKeys: config.semanticKeys ?? true,
+        };
+        // Load persistent cache
+        if (this.config.persistent) {
+            this.loadFromDisk();
+        }
+    }
+    /**
+     * Get cached result
+     */
+    get(server, tool, params) {
+        const key = this.generateKey(server, tool, params);
+        const entry = this.cache.get(key);
+        // Initialize server stats if needed
+        if (!this.stats.byServer[server]) {
+            this.stats.byServer[server] = { hits: 0, misses: 0, entries: 0 };
+        }
+        if (!entry) {
+            this.stats.misses++;
+            this.stats.byServer[server].misses++;
+            this.updateHitRate();
+            return null;
+        }
+        // Check expiration
+        if (Date.now() > entry.expiresAt) {
+            this.delete(key);
+            this.stats.misses++;
+            this.stats.byServer[server].misses++;
+            this.updateHitRate();
+            return null;
+        }
+        // Update LRU order
+        this.updateAccessOrder(key);
+        entry.hits++;
+        this.stats.hits++;
+        this.stats.byServer[server].hits++;
+        this.updateHitRate();
+        return entry;
+    }
+    /**
+     * Cache a result
+     */
+    set(server, tool, params, data) {
+        const ttl = this.getTTL(server);
+        // Don't cache if TTL is 0
+        if (ttl === 0)
+            return;
+        const key = this.generateKey(server, tool, params);
+        const size = this.estimateSize(data);
+        // Evict if necessary
+        this.evictIfNeeded(size);
+        const entry = {
+            key,
+            data,
+            server,
+            tool,
+            createdAt: Date.now(),
+            expiresAt: Date.now() + ttl,
+            hits: 0,
+            size,
+        };
+        this.cache.set(key, entry);
+        this.updateAccessOrder(key);
+        // Update stats
+        this.stats.entries = this.cache.size;
+        this.stats.totalSize += size;
+        if (!this.stats.byServer[server]) {
+            this.stats.byServer[server] = { hits: 0, misses: 0, entries: 0 };
+        }
+        this.stats.byServer[server].entries++;
+        // Persist if enabled
+        if (this.config.persistent) {
+            this.persistEntry(entry);
+        }
+    }
+    /**
+     * Wrap an MCP call with caching
+     */
+    async wrap(server, tool, params, fetcher) {
+        // Check cache first
+        const cached = this.get(server, tool, params);
+        if (cached) {
+            return {
+                success: true,
+                data: cached.data,
+                server,
+                tool,
+                mode: 'real',
+                latency: 0,
+                timestamp: new Date(),
+            };
+        }
+        // Fetch and cache
+        const result = await fetcher();
+        if (result.success && result.data) {
+            this.set(server, tool, params, result.data);
+        }
+        return result;
+    }
+    /**
+     * Invalidate cache entries
+     */
+    invalidate(pattern) {
+        let invalidated = 0;
+        const now = Date.now();
+        for (const [key, entry] of this.cache) {
+            let shouldInvalidate = false;
+            if (pattern.server && entry.server === pattern.server) {
+                shouldInvalidate = true;
+            }
+            if (pattern.tool && entry.tool === pattern.tool) {
+                shouldInvalidate = true;
+            }
+            if (pattern.olderThan && now - entry.createdAt > pattern.olderThan) {
+                shouldInvalidate = true;
+            }
+            if (shouldInvalidate) {
+                this.delete(key);
+                invalidated++;
+            }
+        }
+        return invalidated;
+    }
+    /**
+     * Clear entire cache
+     */
+    clear() {
+        this.cache.clear();
+        this.accessOrder = [];
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            entries: 0,
+            totalSize: 0,
+            hitRate: 0,
+            byServer: {},
+        };
+        if (this.config.persistent) {
+            this.clearDisk();
+        }
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Get cache entries for debugging
+     */
+    getEntries() {
+        return Array.from(this.cache.values());
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    generateKey(server, tool, params) {
+        let paramsStr = JSON.stringify(params, Object.keys(params).sort());
+        // Semantic key normalization
+        if (this.config.semanticKeys) {
+            paramsStr = this.normalizeParams(paramsStr);
+        }
+        const hash = (0, crypto_1.createHash)('sha256')
+            .update(`${server}:${tool}:${paramsStr}`)
+            .digest('hex')
+            .slice(0, 16);
+        return `${server}:${tool}:${hash}`;
+    }
+    normalizeParams(paramsStr) {
+        // Normalize whitespace and case for query-like params
+        return paramsStr
+            .toLowerCase()
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    getTTL(server) {
+        return this.config.serverTTL[server] ?? this.config.defaultTTL;
+    }
+    estimateSize(data) {
+        try {
+            return JSON.stringify(data).length * 2; // Rough estimate for UTF-16
+        }
+        catch {
+            return 1000; // Default estimate
+        }
+    }
+    updateAccessOrder(key) {
+        const index = this.accessOrder.indexOf(key);
+        if (index > -1) {
+            this.accessOrder.splice(index, 1);
+        }
+        this.accessOrder.push(key);
+    }
+    evictIfNeeded(newSize) {
+        // Evict by count
+        while (this.cache.size >= this.config.maxEntries && this.accessOrder.length > 0) {
+            const oldest = this.accessOrder.shift();
+            this.delete(oldest);
+        }
+        // Evict by size
+        while (this.stats.totalSize + newSize > this.config.maxSize && this.accessOrder.length > 0) {
+            const oldest = this.accessOrder.shift();
+            this.delete(oldest);
+        }
+    }
+    delete(key) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            this.stats.totalSize -= entry.size;
+            this.stats.entries--;
+            if (this.stats.byServer[entry.server]) {
+                this.stats.byServer[entry.server].entries--;
+            }
+            this.cache.delete(key);
+            const idx = this.accessOrder.indexOf(key);
+            if (idx > -1) {
+                this.accessOrder.splice(idx, 1);
+            }
+        }
+    }
+    updateHitRate() {
+        const total = this.stats.hits + this.stats.misses;
+        this.stats.hitRate = total > 0 ? this.stats.hits / total : 0;
+    }
+    // ============================================================================
+    // Persistence
+    // ============================================================================
+    loadFromDisk() {
+        try {
+            const indexPath = path.join(this.config.persistPath, 'cache-index.json');
+            if (fs.existsSync(indexPath)) {
+                const index = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+                for (const entry of index.entries) {
+                    if (Date.now() < entry.expiresAt) {
+                        this.cache.set(entry.key, entry);
+                        this.accessOrder.push(entry.key);
+                    }
+                }
+                this.stats.entries = this.cache.size;
+            }
+        }
+        catch {
+            // Ignore load errors
+        }
+    }
+    persistEntry(entry) {
+        try {
+            if (!fs.existsSync(this.config.persistPath)) {
+                fs.mkdirSync(this.config.persistPath, { recursive: true });
+            }
+            const indexPath = path.join(this.config.persistPath, 'cache-index.json');
+            const index = { entries: Array.from(this.cache.values()) };
+            fs.writeFileSync(indexPath, JSON.stringify(index));
+        }
+        catch {
+            // Ignore persist errors
+        }
+    }
+    clearDisk() {
+        try {
+            const indexPath = path.join(this.config.persistPath, 'cache-index.json');
+            if (fs.existsSync(indexPath)) {
+                fs.unlinkSync(indexPath);
+            }
+        }
+        catch {
+            // Ignore clear errors
+        }
+    }
+}
+exports.MCPCache = MCPCache;
+// ============================================================================
+// Singleton
+// ============================================================================
+let cacheInstance = null;
+function getMCPCache(config) {
+    if (!cacheInstance) {
+        cacheInstance = new MCPCache(config);
+    }
+    return cacheInstance;
+}
+function resetMCPCache() {
+    if (cacheInstance) {
+        cacheInstance.clear();
+    }
+    cacheInstance = null;
+}
+// ============================================================================
+// Decorator-style cache wrapper
+// ============================================================================
+function withCache(server, tool, params, fetcher) {
+    return getMCPCache().wrap(server, tool, params, fetcher);
+}

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

@@ -1,5 +1,5 @@
 /**
- * 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.
@@ -8,8 +8,22 @@
  * - 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
  */
 export * from './resilient.js';
+export * from './tool-chain.js';
+export * from './streaming.js';
+export * from './multimodal.js';
+export * from './cache.js';
+export * from './parallel-executor.js';
+export * from './transformers.js';
 import { MCPServerName } from '../types.js';
 export type MCPMode = 'real' | 'simulated' | 'hybrid';
 export interface MCPCallOptions {

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");

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