genesis-ai-cli 7.4.5

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

@@ -0,0 +1,139 @@
+/**
+ * Genesis 6.8 - Resilient MCP Wrapper
+ *
+ * Wraps MCP server calls with:
+ * - Timeout handling
+ * - Automatic retry with exponential backoff
+ * - Fallback to local cache when offline
+ * - Circuit breaker pattern
+ * - Health monitoring
+ */
+export type MCPServerName = 'arxiv' | 'semantic-scholar' | 'context7' | 'wolfram' | 'gemini' | 'brave-search' | 'exa' | 'firecrawl' | 'openai' | 'github' | 'stability-ai' | 'memory' | 'filesystem';
+export interface MCPCallOptions {
+    /** Timeout in ms (default: 30000) */
+    timeout?: number;
+    /** Maximum retries (default: 2) */
+    maxRetries?: number;
+    /** Use cache if offline (default: true) */
+    useCacheFallback?: boolean;
+    /** Priority: 'high' skips queue, 'low' can be delayed */
+    priority?: 'high' | 'normal' | 'low';
+}
+export interface MCPCallResult<T = unknown> {
+    /** Whether call succeeded */
+    success: boolean;
+    /** Response data */
+    data?: T;
+    /** Error message if failed */
+    error?: string;
+    /** Whether result came from cache */
+    cached: boolean;
+    /** Latency in ms */
+    latency: number;
+    /** Server that handled the call */
+    server: MCPServerName;
+    /** Number of retries needed */
+    retries: number;
+}
+export interface ServerHealth {
+    /** Server name */
+    name: MCPServerName;
+    /** Is server currently available */
+    available: boolean;
+    /** Success rate (0-1) */
+    successRate: number;
+    /** Average latency in ms */
+    avgLatency: number;
+    /** Last successful call timestamp */
+    lastSuccess: number;
+    /** Last failure timestamp */
+    lastFailure: number;
+    /** Consecutive failures */
+    consecutiveFailures: number;
+    /** Is circuit breaker open (blocking calls) */
+    circuitOpen: boolean;
+}
+export interface ResilientConfig {
+    /** Default timeout in ms */
+    defaultTimeout: number;
+    /** Default max retries */
+    defaultMaxRetries: number;
+    /** Circuit breaker threshold (consecutive failures to open) */
+    circuitBreakerThreshold: number;
+    /** Circuit breaker reset time in ms */
+    circuitBreakerResetTime: number;
+    /** Enable logging */
+    logCalls: boolean;
+}
+export declare class ResilientMCP {
+    private config;
+    private health;
+    private callHistory;
+    constructor(config?: Partial<ResilientConfig>);
+    /**
+     * Initialize health tracking for all servers
+     */
+    private initializeHealth;
+    /**
+     * Call an MCP server with resilience features
+     */
+    call<T = unknown>(server: MCPServerName, tool: string, params: Record<string, unknown>, options?: MCPCallOptions): Promise<MCPCallResult<T>>;
+    /**
+     * Execute the actual MCP call
+     */
+    private executeCall;
+    /**
+     * Simulate MCP call (placeholder for actual SDK integration)
+     */
+    private simulateMCPCall;
+    /**
+     * Try fallback strategies when primary server fails
+     */
+    private tryFallback;
+    /**
+     * Try to find result in local cache
+     */
+    private tryCache;
+    /**
+     * Try to find result in project index
+     */
+    private tryProjectIndex;
+    /**
+     * Find an alternative server in the same category
+     */
+    private findAlternativeServer;
+    private recordSuccess;
+    private recordFailure;
+    private updateSuccessRate;
+    /**
+     * Get health status for all servers
+     */
+    getHealth(): ServerHealth[];
+    /**
+     * Get health status for a specific server
+     */
+    getServerHealth(server: MCPServerName): ServerHealth | undefined;
+    /**
+     * Reset circuit breaker for a server
+     */
+    resetCircuitBreaker(server: MCPServerName): void;
+    /**
+     * Check if a server is available
+     */
+    isAvailable(server: MCPServerName): boolean;
+    /**
+     * Get list of available servers
+     */
+    getAvailableServers(): MCPServerName[];
+    private delay;
+}
+export declare function getResilientMCP(config?: Partial<ResilientConfig>): ResilientMCP;
+export declare function resetResilientMCP(): void;
+/**
+ * Call MCP server with automatic resilience
+ */
+export declare function mcpCall<T = unknown>(server: MCPServerName, tool: string, params: Record<string, unknown>, options?: MCPCallOptions): Promise<MCPCallResult<T>>;
+/**
+ * Check if MCP servers are healthy
+ */
+export declare function mcpHealthCheck(): ServerHealth[];

package/dist/src/mcp/resilient.js

@@ -0,0 +1,417 @@
+"use strict";
+/**
+ * Genesis 6.8 - Resilient MCP Wrapper
+ *
+ * Wraps MCP server calls with:
+ * - Timeout handling
+ * - Automatic retry with exponential backoff
+ * - Fallback to local cache when offline
+ * - Circuit breaker pattern
+ * - Health monitoring
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResilientMCP = void 0;
+exports.getResilientMCP = getResilientMCP;
+exports.resetResilientMCP = resetResilientMCP;
+exports.mcpCall = mcpCall;
+exports.mcpHealthCheck = mcpHealthCheck;
+const cache_js_1 = require("../memory/cache.js");
+const indexer_js_1 = require("../memory/indexer.js");
+// ============================================================================
+// Default Config
+// ============================================================================
+const DEFAULT_CONFIG = {
+    defaultTimeout: 30000,
+    defaultMaxRetries: 2,
+    circuitBreakerThreshold: 5,
+    circuitBreakerResetTime: 60000,
+    logCalls: false,
+};
+// ============================================================================
+// Server Categories (for fallback logic)
+// ============================================================================
+const SERVER_CATEGORIES = {
+    search: ['brave-search', 'exa', 'gemini', 'firecrawl'],
+    papers: ['arxiv', 'semantic-scholar'],
+    docs: ['context7'],
+    math: ['wolfram'],
+    code: ['github', 'openai'],
+    images: ['stability-ai'],
+    storage: ['memory', 'filesystem'],
+};
+// ============================================================================
+// Resilient MCP Wrapper
+// ============================================================================
+class ResilientMCP {
+    config;
+    health = new Map();
+    callHistory = [];
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.initializeHealth();
+    }
+    /**
+     * Initialize health tracking for all servers
+     */
+    initializeHealth() {
+        const servers = [
+            'arxiv', 'semantic-scholar', 'context7', 'wolfram',
+            'gemini', 'brave-search', 'exa', 'firecrawl',
+            'openai', 'github', 'stability-ai',
+            'memory', 'filesystem',
+        ];
+        for (const server of servers) {
+            this.health.set(server, {
+                name: server,
+                available: true,
+                successRate: 1,
+                avgLatency: 0,
+                lastSuccess: 0,
+                lastFailure: 0,
+                consecutiveFailures: 0,
+                circuitOpen: false,
+            });
+        }
+    }
+    // ==========================================================================
+    // Core Call Method
+    // ==========================================================================
+    /**
+     * Call an MCP server with resilience features
+     */
+    async call(server, tool, params, options = {}) {
+        const { timeout = this.config.defaultTimeout, maxRetries = this.config.defaultMaxRetries, useCacheFallback = true, } = options;
+        const startTime = Date.now();
+        const health = this.health.get(server);
+        // Check circuit breaker
+        if (health.circuitOpen) {
+            const timeSinceLastFailure = Date.now() - health.lastFailure;
+            if (timeSinceLastFailure < this.config.circuitBreakerResetTime) {
+                // Circuit still open - try cache or alternative
+                if (useCacheFallback) {
+                    return this.tryFallback(server, tool, params, startTime);
+                }
+                return {
+                    success: false,
+                    error: `Circuit breaker open for ${server}`,
+                    cached: false,
+                    latency: Date.now() - startTime,
+                    server,
+                    retries: 0,
+                };
+            }
+            // Reset circuit breaker (half-open state)
+            health.circuitOpen = false;
+        }
+        // Try the call with retries
+        let lastError = '';
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                const result = await this.executeCall(server, tool, params, timeout);
+                this.recordSuccess(server, Date.now() - startTime);
+                return {
+                    success: true,
+                    data: result,
+                    cached: false,
+                    latency: Date.now() - startTime,
+                    server,
+                    retries: attempt,
+                };
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error.message : String(error);
+                if (this.config.logCalls) {
+                    console.log(`[MCP] ${server}.${tool} attempt ${attempt + 1} failed: ${lastError}`);
+                }
+                // Exponential backoff before retry
+                if (attempt < maxRetries) {
+                    await this.delay(Math.pow(2, attempt) * 500);
+                }
+            }
+        }
+        // All retries failed
+        this.recordFailure(server);
+        // Try fallback
+        if (useCacheFallback) {
+            return this.tryFallback(server, tool, params, startTime, lastError);
+        }
+        return {
+            success: false,
+            error: lastError,
+            cached: false,
+            latency: Date.now() - startTime,
+            server,
+            retries: maxRetries,
+        };
+    }
+    /**
+     * Execute the actual MCP call
+     */
+    async executeCall(server, tool, params, timeout) {
+        // This is a placeholder - in real implementation, this would call the MCP SDK
+        // For now, we simulate the call structure
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            // Simulate MCP call based on server type
+            // In production, this would use @modelcontextprotocol/sdk
+            const result = await this.simulateMCPCall(server, tool, params, controller.signal);
+            return result;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Simulate MCP call (placeholder for actual SDK integration)
+     */
+    async simulateMCPCall(server, tool, params, signal) {
+        // In production, this would be replaced with actual MCP SDK calls
+        // For now, throw to trigger fallback logic demonstration
+        if (server === 'filesystem' || server === 'memory') {
+            // Local servers always work
+            return { success: true, tool, params };
+        }
+        // Simulate network call
+        const response = await fetch(`http://localhost:3000/mcp/${server}/${tool}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(params),
+            signal,
+        }).catch(() => {
+            throw new Error(`${server} is offline or unreachable`);
+        });
+        if (!response.ok) {
+            throw new Error(`${server} returned ${response.status}`);
+        }
+        return response.json();
+    }
+    // ==========================================================================
+    // Fallback Logic
+    // ==========================================================================
+    /**
+     * Try fallback strategies when primary server fails
+     */
+    async tryFallback(server, tool, params, startTime, originalError) {
+        // Strategy 1: Try local cache
+        const cacheResult = this.tryCache(server, tool, params);
+        if (cacheResult) {
+            return {
+                success: true,
+                data: cacheResult,
+                cached: true,
+                latency: Date.now() - startTime,
+                server,
+                retries: 0,
+            };
+        }
+        // Strategy 2: Try project indexer for search operations
+        if (tool.includes('search') || tool.includes('find')) {
+            const indexResult = await this.tryProjectIndex(params);
+            if (indexResult) {
+                return {
+                    success: true,
+                    data: indexResult,
+                    cached: true,
+                    latency: Date.now() - startTime,
+                    server,
+                    retries: 0,
+                };
+            }
+        }
+        // Strategy 3: Try alternative server in same category
+        const alternative = this.findAlternativeServer(server);
+        if (alternative) {
+            if (this.config.logCalls) {
+                console.log(`[MCP] Trying alternative server: ${alternative}`);
+            }
+            // Recursive call with alternative (but no further fallback)
+            return this.call(alternative, tool, params, { useCacheFallback: false });
+        }
+        return {
+            success: false,
+            error: originalError || `${server} unavailable, no fallback found`,
+            cached: false,
+            latency: Date.now() - startTime,
+            server,
+            retries: 0,
+        };
+    }
+    /**
+     * Try to find result in local cache
+     */
+    tryCache(server, tool, params) {
+        // For now, only cache fix results
+        if (server === 'openai' && tool.includes('fix')) {
+            const cache = (0, cache_js_1.getFixCache)();
+            const errorMessage = params.error;
+            const filePath = params.file;
+            if (errorMessage && filePath) {
+                const cached = cache.lookup(errorMessage, filePath, '');
+                if (cached) {
+                    return { fix: cached.fix, cached: true };
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Try to find result in project index
+     */
+    async tryProjectIndex(params) {
+        const query = params.query || params.search || params.q;
+        if (!query)
+            return null;
+        try {
+            const indexer = (0, indexer_js_1.getProjectIndexer)();
+            const results = indexer.search(query, { limit: 5 });
+            if (results.length > 0) {
+                return {
+                    source: 'local-index',
+                    results: results.map(r => ({
+                        file: r.path,
+                        matches: r.matches.length,
+                        preview: r.matches[0]?.content || '',
+                    })),
+                };
+            }
+        }
+        catch {
+            // Index not available
+        }
+        return null;
+    }
+    /**
+     * Find an alternative server in the same category
+     */
+    findAlternativeServer(server) {
+        for (const [, servers] of Object.entries(SERVER_CATEGORIES)) {
+            const index = servers.indexOf(server);
+            if (index !== -1) {
+                // Find next available server in category
+                for (let i = 1; i < servers.length; i++) {
+                    const alt = servers[(index + i) % servers.length];
+                    const health = this.health.get(alt);
+                    if (health && !health.circuitOpen && health.consecutiveFailures < 3) {
+                        return alt;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    // ==========================================================================
+    // Health Tracking
+    // ==========================================================================
+    recordSuccess(server, latency) {
+        const health = this.health.get(server);
+        health.lastSuccess = Date.now();
+        health.consecutiveFailures = 0;
+        health.circuitOpen = false;
+        health.available = true;
+        // Update average latency
+        health.avgLatency = health.avgLatency === 0
+            ? latency
+            : health.avgLatency * 0.9 + latency * 0.1;
+        // Update success rate
+        this.callHistory.push({ server, success: true, latency, timestamp: Date.now() });
+        this.updateSuccessRate(server);
+    }
+    recordFailure(server) {
+        const health = this.health.get(server);
+        health.lastFailure = Date.now();
+        health.consecutiveFailures++;
+        // Check circuit breaker
+        if (health.consecutiveFailures >= this.config.circuitBreakerThreshold) {
+            health.circuitOpen = true;
+            health.available = false;
+            console.log(`[MCP] Circuit breaker OPEN for ${server}`);
+        }
+        this.callHistory.push({ server, success: false, latency: 0, timestamp: Date.now() });
+        this.updateSuccessRate(server);
+    }
+    updateSuccessRate(server) {
+        const recentCalls = this.callHistory
+            .filter(c => c.server === server && Date.now() - c.timestamp < 300000); // Last 5 min
+        if (recentCalls.length > 0) {
+            const health = this.health.get(server);
+            health.successRate = recentCalls.filter(c => c.success).length / recentCalls.length;
+        }
+    }
+    // ==========================================================================
+    // Public API
+    // ==========================================================================
+    /**
+     * Get health status for all servers
+     */
+    getHealth() {
+        return Array.from(this.health.values());
+    }
+    /**
+     * Get health status for a specific server
+     */
+    getServerHealth(server) {
+        return this.health.get(server);
+    }
+    /**
+     * Reset circuit breaker for a server
+     */
+    resetCircuitBreaker(server) {
+        const health = this.health.get(server);
+        if (health) {
+            health.circuitOpen = false;
+            health.consecutiveFailures = 0;
+            health.available = true;
+        }
+    }
+    /**
+     * Check if a server is available
+     */
+    isAvailable(server) {
+        const health = this.health.get(server);
+        return health ? health.available && !health.circuitOpen : false;
+    }
+    /**
+     * Get list of available servers
+     */
+    getAvailableServers() {
+        return Array.from(this.health.entries())
+            .filter(([, h]) => h.available && !h.circuitOpen)
+            .map(([name]) => name);
+    }
+    // ==========================================================================
+    // Utilities
+    // ==========================================================================
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.ResilientMCP = ResilientMCP;
+// ============================================================================
+// Singleton
+// ============================================================================
+let resilientMCPInstance = null;
+function getResilientMCP(config) {
+    if (!resilientMCPInstance) {
+        resilientMCPInstance = new ResilientMCP(config);
+    }
+    return resilientMCPInstance;
+}
+function resetResilientMCP() {
+    resilientMCPInstance = null;
+}
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+/**
+ * Call MCP server with automatic resilience
+ */
+async function mcpCall(server, tool, params, options) {
+    return getResilientMCP().call(server, tool, params, options);
+}
+/**
+ * Check if MCP servers are healthy
+ */
+function mcpHealthCheck() {
+    return getResilientMCP().getHealth();
+}

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

@@ -0,0 +1,118 @@
+/**
+ * Genesis 6.8 - SQLite Fix Cache
+ *
+ * Stores successful fixes from Self-Healing module for instant reuse.
+ * Uses better-sqlite3 for synchronous, high-performance operations.
+ *
+ * Key: SHA256(error_message + file_path + context)
+ * Value: Applied fix with metadata
+ */
+export interface CachedFix {
+    /** Unique hash of error + context */
+    id: string;
+    /** Original error message */
+    errorMessage: string;
+    /** Error type (syntax, type, runtime, test, build, lint) */
+    errorType: string;
+    /** File path where error occurred */
+    filePath: string;
+    /** Code context around error */
+    context: string;
+    /** Applied fix */
+    fix: string;
+    /** Number of times this fix was used successfully */
+    successCount: number;
+    /** Last time this fix was used */
+    lastUsed: number;
+    /** When this fix was first created */
+    createdAt: number;
+    /** LLM provider that generated this fix (for stats) */
+    provider?: string;
+    /** Latency when fix was generated (for stats) */
+    latencyMs?: number;
+}
+export interface CacheStats {
+    totalFixes: number;
+    totalHits: number;
+    hitRate: number;
+    avgLatencySaved: number;
+    topErrors: Array<{
+        type: string;
+        count: number;
+    }>;
+    dbSizeBytes: number;
+}
+export interface CacheConfig {
+    /** Path to SQLite database file */
+    dbPath: string;
+    /** Maximum number of fixes to cache (LRU eviction) */
+    maxFixes: number;
+    /** Minimum success count to keep a fix during eviction */
+    minSuccessCount: number;
+    /** Enable FTS5 for full-text search */
+    enableFTS: boolean;
+}
+export declare class FixCache {
+    private config;
+    private cache;
+    constructor(config?: Partial<CacheConfig>);
+    /**
+     * Generate cache key from error details
+     */
+    generateKey(errorMessage: string, filePath: string, context?: string): string;
+    /**
+     * Look up a cached fix
+     */
+    lookup(errorMessage: string, filePath: string, context?: string): CachedFix | null;
+    /**
+     * Store a successful fix
+     */
+    store(params: {
+        errorMessage: string;
+        errorType: string;
+        filePath: string;
+        context: string;
+        fix: string;
+        provider?: string;
+        latencyMs?: number;
+    }): CachedFix;
+    /**
+     * Search for similar errors
+     */
+    searchSimilar(query: string, limit?: number): CachedFix[];
+    /**
+     * Get all cached fixes
+     */
+    getAll(): CachedFix[];
+    /**
+     * Get cache statistics
+     */
+    stats(): CacheStats;
+    /**
+     * Clear all cached fixes
+     */
+    clear(): void;
+    /**
+     * Delete a specific fix
+     */
+    delete(id: string): boolean;
+    /**
+     * Close the cache (save to disk)
+     */
+    close(): void;
+    private evictIfNeeded;
+}
+export declare function getFixCache(config?: Partial<CacheConfig>): FixCache;
+export declare function resetFixCache(): void;
+/**
+ * Try to get a cached fix before calling LLM
+ */
+export declare function getCachedFixOrGenerate(errorMessage: string, errorType: string, filePath: string, context: string, generateFix: () => Promise<{
+    fix: string;
+    provider: string;
+    latencyMs: number;
+}>): Promise<{
+    fix: string;
+    cached: boolean;
+    latencyMs: number;
+}>;