genesis-ai-cli 7.4.5

package/dist/src/llm/router.js

@@ -0,0 +1,510 @@
+"use strict";
+/**
+ * Genesis 6.8 - Hybrid LLM Router
+ *
+ * Intelligent routing between local (Ollama) and cloud (OpenAI/Anthropic) LLMs.
+ *
+ * Routing Logic:
+ * - Simple tasks (syntax fix, file ops, search) -> Local (fast, free)
+ * - Complex tasks (architecture, design, creative) -> Cloud (high quality)
+ *
+ * Factors considered:
+ * - Task complexity (heuristic analysis)
+ * - Token count estimation
+ * - Ollama availability
+ * - User preference
+ * - Cost optimization
+ */
+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.HybridRouter = void 0;
+exports.detectHardware = detectHardware;
+exports.analyzeComplexity = analyzeComplexity;
+exports.estimateTokens = estimateTokens;
+exports.estimateCost = estimateCost;
+exports.getHybridRouter = getHybridRouter;
+exports.resetHybridRouter = resetHybridRouter;
+exports.smartChat = smartChat;
+exports.localChat = localChat;
+exports.cloudChat = cloudChat;
+const index_js_1 = require("./index.js");
+const os = __importStar(require("os"));
+/**
+ * Detect hardware capabilities and recommend router config
+ */
+function detectHardware() {
+    const cpus = os.cpus();
+    const cpu = cpus[0]?.model || 'Unknown';
+    const cores = cpus.length;
+    const memoryGB = Math.round(os.totalmem() / (1024 ** 3));
+    // Detect Apple Silicon
+    const isAppleSilicon = cpu.includes('Apple M') ||
+        process.arch === 'arm64' && process.platform === 'darwin';
+    // Determine tier
+    let tier;
+    let recommendedThreshold;
+    let recommendedMaxTokens;
+    if (isAppleSilicon && memoryGB >= 24) {
+        // M3 Pro/Max/Ultra or M4 Pro/Max - top tier
+        tier = 'ultra';
+        recommendedThreshold = 'creative'; // Only creative to cloud
+        recommendedMaxTokens = 16384; // Can handle large context
+    }
+    else if (isAppleSilicon && memoryGB >= 16) {
+        // M1/M2/M3/M4 base with good RAM
+        tier = 'high';
+        recommendedThreshold = 'creative';
+        recommendedMaxTokens = 8192;
+    }
+    else if (cores >= 8 && memoryGB >= 16) {
+        // Good desktop/laptop
+        tier = 'medium';
+        recommendedThreshold = 'complex';
+        recommendedMaxTokens = 4096;
+    }
+    else {
+        // Limited hardware
+        tier = 'low';
+        recommendedThreshold = 'moderate'; // Route more to cloud
+        recommendedMaxTokens = 2048;
+    }
+    return {
+        cpu,
+        isAppleSilicon,
+        cores,
+        memoryGB,
+        tier,
+        recommendedThreshold,
+        recommendedMaxTokens,
+    };
+}
+// ============================================================================
+// Default Config
+// ============================================================================
+const DEFAULT_CONFIG = {
+    preferLocal: true,
+    forceCloud: false,
+    localMaxTokens: 8192, // M4 Pro can handle larger context
+    cloudThreshold: 'creative', // Only creative → cloud (M4 Pro is fast enough for complex)
+    autoFallback: true,
+    logDecisions: false,
+};
+// ============================================================================
+// Complexity Analysis
+// ============================================================================
+const COMPLEXITY_SCORES = {
+    trivial: 0,
+    simple: 1,
+    moderate: 2,
+    complex: 3,
+    creative: 4,
+};
+/**
+ * Keywords that indicate simple/local tasks
+ */
+const LOCAL_KEYWORDS = [
+    // Syntax & Formatting
+    'fix syntax', 'typo', 'spelling', 'indent', 'format',
+    'semicolon', 'bracket', 'parenthesis', 'quote',
+    // File Operations
+    'rename', 'move file', 'delete file', 'list files',
+    'find file', 'search', 'grep', 'locate',
+    // Simple Code Tasks
+    'add import', 'remove import', 'update import',
+    'add export', 'rename variable', 'rename function',
+    'add comment', 'remove comment', 'update comment',
+    // Git Operations
+    'git status', 'git diff', 'git log', 'git add',
+    'commit message', 'branch name',
+    // Quick Fixes
+    'missing semicolon', 'missing bracket', 'missing import',
+    'unused variable', 'undefined variable',
+    'type error', 'typescript error',
+];
+/**
+ * Keywords that indicate complex/cloud tasks
+ */
+const CLOUD_KEYWORDS = [
+    // Architecture
+    'design', 'architect', 'structure', 'pattern',
+    'refactor', 'restructure', 'reorganize',
+    // Creative
+    'create', 'implement', 'build', 'develop',
+    'new feature', 'add feature', 'write from scratch',
+    // Complex Analysis
+    'analyze', 'review', 'evaluate', 'assess',
+    'optimize', 'improve', 'enhance',
+    // Documentation
+    'document', 'explain', 'describe', 'tutorial',
+    'readme', 'api docs', 'specification',
+    // Testing
+    'write tests', 'test coverage', 'integration test',
+    'e2e test', 'test strategy',
+    // Multi-step
+    'step by step', 'multiple files', 'across the codebase',
+    'entire project', 'all files',
+];
+/**
+ * Analyze task complexity from the prompt
+ */
+function analyzeComplexity(prompt) {
+    const lower = prompt.toLowerCase();
+    const indicators = [];
+    let localScore = 0;
+    let cloudScore = 0;
+    // Check local keywords
+    for (const keyword of LOCAL_KEYWORDS) {
+        if (lower.includes(keyword)) {
+            localScore++;
+            indicators.push(`local: "${keyword}"`);
+        }
+    }
+    // Check cloud keywords
+    for (const keyword of CLOUD_KEYWORDS) {
+        if (lower.includes(keyword)) {
+            cloudScore++;
+            indicators.push(`cloud: "${keyword}"`);
+        }
+    }
+    // Additional heuristics
+    const wordCount = prompt.split(/\s+/).length;
+    const hasCode = prompt.includes('```') || prompt.includes('function ') || prompt.includes('class ');
+    const hasMultipleQuestions = (prompt.match(/\?/g) || []).length > 1;
+    const hasNumberedList = /\d+\.\s/.test(prompt);
+    if (wordCount > 200) {
+        cloudScore += 2;
+        indicators.push('long prompt');
+    }
+    if (hasCode && wordCount > 100) {
+        cloudScore++;
+        indicators.push('code + explanation');
+    }
+    if (hasMultipleQuestions) {
+        cloudScore++;
+        indicators.push('multiple questions');
+    }
+    if (hasNumberedList) {
+        cloudScore++;
+        indicators.push('multi-step task');
+    }
+    // Calculate final complexity
+    const netScore = cloudScore - localScore;
+    let complexity;
+    if (netScore <= -2)
+        complexity = 'trivial';
+    else if (netScore <= 0)
+        complexity = 'simple';
+    else if (netScore <= 2)
+        complexity = 'moderate';
+    else if (netScore <= 4)
+        complexity = 'complex';
+    else
+        complexity = 'creative';
+    // Confidence based on indicator count
+    const totalIndicators = localScore + cloudScore;
+    const confidence = Math.min(0.9, 0.3 + (totalIndicators * 0.1));
+    return { complexity, confidence, indicators };
+}
+/**
+ * Estimate token count from prompt
+ */
+function estimateTokens(text) {
+    // Rough estimation: ~4 characters per token for English
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Estimate cost for cloud provider
+ */
+function estimateCost(inputTokens, outputTokens, provider) {
+    // Prices per 1M tokens (as of 2024)
+    const prices = {
+        openai: { input: 2.5, output: 10 }, // GPT-4o
+        anthropic: { input: 3, output: 15 }, // Claude Sonnet
+        ollama: { input: 0, output: 0 }, // Free!
+    };
+    const p = prices[provider];
+    return ((inputTokens * p.input) + (outputTokens * p.output)) / 1_000_000;
+}
+// ============================================================================
+// Hybrid Router Class
+// ============================================================================
+class HybridRouter {
+    config;
+    stats = {
+        totalRequests: 0,
+        localRequests: 0,
+        cloudRequests: 0,
+        fallbacks: 0,
+        avgLocalLatency: 0,
+        avgCloudLatency: 0,
+        estimatedSavings: 0,
+    };
+    localBridge = null;
+    cloudBridge = null;
+    hardwareProfile;
+    constructor(config) {
+        // Detect hardware and auto-configure
+        this.hardwareProfile = detectHardware();
+        // Apply hardware-based defaults, then user overrides
+        this.config = {
+            ...DEFAULT_CONFIG,
+            cloudThreshold: this.hardwareProfile.recommendedThreshold,
+            localMaxTokens: this.hardwareProfile.recommendedMaxTokens,
+            ...config,
+        };
+        if (this.config.logDecisions) {
+            console.log(`[Router] Hardware: ${this.hardwareProfile.tier} tier (${this.hardwareProfile.cpu})`);
+            console.log(`[Router] Config: cloudThreshold=${this.config.cloudThreshold}, localMaxTokens=${this.config.localMaxTokens}`);
+        }
+    }
+    /**
+     * Get detected hardware profile
+     */
+    getHardwareProfile() {
+        return { ...this.hardwareProfile };
+    }
+    // ==========================================================================
+    // Routing Logic
+    // ==========================================================================
+    /**
+     * Decide which provider to use
+     */
+    async route(prompt) {
+        const { complexity, confidence, indicators } = analyzeComplexity(prompt);
+        const estimatedTokens = estimateTokens(prompt);
+        const estimatedOutputTokens = Math.min(estimatedTokens * 2, 2000);
+        // Force cloud if configured
+        if (this.config.forceCloud) {
+            return {
+                provider: process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai',
+                reason: 'Force cloud mode enabled',
+                complexity,
+                confidence: 1,
+                estimatedTokens,
+                estimatedCost: estimateCost(estimatedTokens, estimatedOutputTokens, 'anthropic'),
+                tryLocalFirst: false,
+            };
+        }
+        // Check if Ollama is available
+        const ollamaAvailable = await this.isOllamaAvailable();
+        // Prefer local if configured and available
+        if (this.config.preferLocal && ollamaAvailable) {
+            const threshold = COMPLEXITY_SCORES[this.config.cloudThreshold];
+            const score = COMPLEXITY_SCORES[complexity];
+            if (score < threshold) {
+                return {
+                    provider: 'ollama',
+                    reason: `Task complexity (${complexity}) below cloud threshold (${this.config.cloudThreshold})`,
+                    complexity,
+                    confidence,
+                    estimatedTokens,
+                    estimatedCost: 0,
+                    tryLocalFirst: true,
+                };
+            }
+        }
+        // Token limit check for local
+        if (estimatedTokens > this.config.localMaxTokens) {
+            return {
+                provider: process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai',
+                reason: `Token count (${estimatedTokens}) exceeds local limit (${this.config.localMaxTokens})`,
+                complexity,
+                confidence,
+                estimatedTokens,
+                estimatedCost: estimateCost(estimatedTokens, estimatedOutputTokens, 'anthropic'),
+                tryLocalFirst: false,
+            };
+        }
+        // Default: use local if available, else cloud
+        if (ollamaAvailable) {
+            return {
+                provider: 'ollama',
+                reason: 'Local model available, using for cost savings',
+                complexity,
+                confidence,
+                estimatedTokens,
+                estimatedCost: 0,
+                tryLocalFirst: true,
+            };
+        }
+        return {
+            provider: process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai',
+            reason: 'Ollama not available, using cloud',
+            complexity,
+            confidence,
+            estimatedTokens,
+            estimatedCost: estimateCost(estimatedTokens, estimatedOutputTokens, 'anthropic'),
+            tryLocalFirst: false,
+        };
+    }
+    /**
+     * Execute request with routing
+     */
+    async execute(prompt, systemPrompt) {
+        const decision = await this.route(prompt);
+        if (this.config.logDecisions) {
+            console.log(`[Router] ${decision.provider}: ${decision.reason} (${decision.complexity}, ${decision.confidence.toFixed(2)})`);
+        }
+        this.stats.totalRequests++;
+        try {
+            const bridge = this.getBridge(decision.provider);
+            const response = await bridge.chat(prompt, systemPrompt);
+            // Update stats
+            if (decision.provider === 'ollama') {
+                this.stats.localRequests++;
+                this.stats.avgLocalLatency = this.updateAverage(this.stats.avgLocalLatency, response.latency, this.stats.localRequests);
+                // Calculate savings vs cloud
+                const cloudCost = estimateCost(response.usage?.inputTokens || 0, response.usage?.outputTokens || 0, 'anthropic');
+                this.stats.estimatedSavings += cloudCost;
+            }
+            else {
+                this.stats.cloudRequests++;
+                this.stats.avgCloudLatency = this.updateAverage(this.stats.avgCloudLatency, response.latency, this.stats.cloudRequests);
+            }
+            return { ...response, routingDecision: decision };
+        }
+        catch (error) {
+            // Auto-fallback if enabled
+            if (this.config.autoFallback && decision.provider === 'ollama') {
+                console.log('[Router] Local failed, falling back to cloud...');
+                this.stats.fallbacks++;
+                const fallbackProvider = process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai';
+                const bridge = this.getBridge(fallbackProvider);
+                const response = await bridge.chat(prompt, systemPrompt);
+                return {
+                    ...response,
+                    routingDecision: {
+                        ...decision,
+                        provider: fallbackProvider,
+                        reason: `Fallback from Ollama: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                };
+            }
+            throw error;
+        }
+    }
+    // ==========================================================================
+    // Helpers
+    // ==========================================================================
+    async isOllamaAvailable() {
+        try {
+            const response = await fetch('http://localhost:11434/api/tags', {
+                signal: AbortSignal.timeout(1000),
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    getBridge(provider) {
+        if (provider === 'ollama') {
+            if (!this.localBridge) {
+                this.localBridge = new index_js_1.LLMBridge({ provider: 'ollama' });
+            }
+            return this.localBridge;
+        }
+        if (!this.cloudBridge) {
+            this.cloudBridge = new index_js_1.LLMBridge({ provider });
+        }
+        return this.cloudBridge;
+    }
+    updateAverage(current, newValue, count) {
+        return current + (newValue - current) / count;
+    }
+    // ==========================================================================
+    // Stats & Config
+    // ==========================================================================
+    getStats() {
+        return { ...this.stats };
+    }
+    resetStats() {
+        this.stats = {
+            totalRequests: 0,
+            localRequests: 0,
+            cloudRequests: 0,
+            fallbacks: 0,
+            avgLocalLatency: 0,
+            avgCloudLatency: 0,
+            estimatedSavings: 0,
+        };
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    setConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+}
+exports.HybridRouter = HybridRouter;
+// ============================================================================
+// Singleton
+// ============================================================================
+let routerInstance = null;
+function getHybridRouter(config) {
+    if (!routerInstance) {
+        routerInstance = new HybridRouter(config);
+    }
+    return routerInstance;
+}
+function resetHybridRouter() {
+    routerInstance = null;
+}
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+/**
+ * Smart chat: automatically routes to best provider
+ */
+async function smartChat(prompt, systemPrompt) {
+    const router = getHybridRouter();
+    const result = await router.execute(prompt, systemPrompt);
+    return result;
+}
+/**
+ * Force local chat (Ollama)
+ */
+async function localChat(prompt, systemPrompt) {
+    const bridge = new index_js_1.LLMBridge({ provider: 'ollama' });
+    return bridge.chat(prompt, systemPrompt);
+}
+/**
+ * Force cloud chat
+ */
+async function cloudChat(prompt, systemPrompt) {
+    const provider = process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'openai';
+    const bridge = new index_js_1.LLMBridge({ provider });
+    return bridge.chat(prompt, systemPrompt);
+}

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

@@ -0,0 +1,85 @@
+/**
+ * Genesis 6.8 - Real MCP Client Module
+ *
+ * Connects to actual MCP servers using @modelcontextprotocol/sdk.
+ * Spawns servers on demand and manages connections.
+ *
+ * Environment Variables:
+ * - 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)
+ */
+export * from './resilient.js';
+import { MCPServerName } from '../types.js';
+export type MCPMode = 'real' | 'simulated' | 'hybrid';
+export interface MCPCallOptions {
+    timeout?: number;
+    retries?: number;
+    fallbackToSimulated?: boolean;
+}
+export interface MCPCallResult<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    server: MCPServerName;
+    tool: string;
+    mode: 'real' | 'simulated';
+    latency: number;
+    timestamp: Date;
+}
+export interface MCPClientConfig {
+    mode: MCPMode;
+    timeout: number;
+    logCalls: boolean;
+    onCall?: (server: MCPServerName, tool: string, params: any) => void;
+    onResult?: (result: MCPCallResult) => void;
+}
+interface MCPServerInfo {
+    command: string;
+    args: string[] | (() => string[]);
+    envVars?: Record<string, string> | (() => Record<string, string>);
+    tools: string[];
+}
+/**
+ * Registry of MCP servers and how to spawn them.
+ * These are the 13 MCP servers Genesis uses.
+ *
+ * Package sources (verified on npm):
+ * - Official: @modelcontextprotocol/server-*
+ * - Third-party: arxiv-mcp-server, @brave/brave-search-mcp-server, etc.
+ */
+declare const MCP_SERVER_REGISTRY: Record<MCPServerName, MCPServerInfo>;
+/**
+ * MCP Tool definition with full schema (from MCP SDK)
+ */
+export interface MCPToolDefinition {
+    name: string;
+    description?: string;
+    inputSchema?: {
+        type: 'object';
+        properties?: Record<string, {
+            type?: string;
+            description?: string;
+            enum?: string[];
+            items?: any;
+        }>;
+        required?: string[];
+    };
+}
+export interface IMCPClient {
+    call<T = any>(server: MCPServerName, tool: string, params: Record<string, any>, options?: MCPCallOptions): Promise<MCPCallResult<T>>;
+    listTools(server: MCPServerName): Promise<string[]>;
+    listToolsWithSchema(server: MCPServerName): Promise<MCPToolDefinition[]>;
+    discoverAllTools(): Promise<Record<MCPServerName, MCPToolDefinition[]>>;
+    isAvailable(server: MCPServerName): Promise<boolean>;
+    getMode(): MCPMode;
+    setMode(mode: MCPMode): void;
+    close(): Promise<void>;
+}
+export declare function getMCPClient(config?: Partial<MCPClientConfig>): IMCPClient;
+export declare function resetMCPClient(): void;
+export declare const mcpClient: IMCPClient;
+export declare function isSimulatedMode(): boolean;
+export declare function isSimulatedResult(result: MCPCallResult): boolean;
+export declare function logMCPMode(): void;
+export { MCP_SERVER_REGISTRY };