genesis-ai-cli 7.4.5

package/dist/src/llm/index.js

@@ -0,0 +1,428 @@
+"use strict";
+/**
+ * Genesis 6.8 - LLM Bridge
+ *
+ * Direct API integration with LLM providers:
+ * - Ollama (Mistral, Qwen, Phi) - LOCAL, FREE
+ * - OpenAI (GPT-4o, o1) - CLOUD, PAID
+ * - Anthropic (Claude) - CLOUD, PAID
+ *
+ * Hybrid routing: use local for 80% of tasks, cloud for complex ones.
+ * No external dependencies - uses native fetch.
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMBridge = exports.GENESIS_SYSTEM_PROMPT = exports.GENESIS_IDENTITY_PROMPT = exports.OLLAMA_CONFIG = void 0;
+exports.buildSystemPrompt = buildSystemPrompt;
+exports.createLLMBridge = createLLMBridge;
+exports.getLLMBridge = getLLMBridge;
+exports.resetLLMBridge = resetLLMBridge;
+// Re-export Phase 8: Hybrid Router
+__exportStar(require("./router.js"), exports);
+// Ollama config
+exports.OLLAMA_CONFIG = {
+    baseUrl: process.env.OLLAMA_HOST || 'http://localhost:11434',
+    defaultModel: 'qwen2.5-coder', // Best for code: 7x faster, concise output
+    models: {
+        'qwen2.5-coder': { name: 'qwen2.5-coder', description: 'Qwen 2.5 Coder - Code specialist (DEFAULT)' },
+        'mistral': { name: 'mistral', description: 'Mistral 7B - Best for chat' },
+        'mistral-small': { name: 'mistral-small', description: 'Mistral Small 24B - High quality' },
+        'deepseek-coder': { name: 'deepseek-coder', description: 'DeepSeek Coder - Lightweight (776MB)' },
+        'phi3.5': { name: 'phi3.5', description: 'Phi-3.5 - Fast, lightweight' },
+    },
+};
+// ============================================================================
+// Default System Prompt
+// ============================================================================
+// ============================================================================
+// Core Identity Prompt (minimal, static)
+// ============================================================================
+exports.GENESIS_IDENTITY_PROMPT = `# Genesis System
+
+You are Genesis - an autopoietic AI system with integrated reasoning, memory, and tool execution.
+
+## Architecture
+- 13 MCP Servers for external capabilities
+- Brain Module with Neural Integration
+- Active Inference for goal-directed behavior
+- Knowledge graph memory with anticipatory retrieval
+- Darwin-Gödel self-improvement mechanism
+
+## Capabilities (verify with /mcp)
+- Research: arxiv, semantic-scholar
+- Web search: brave-search, gemini, exa, firecrawl
+- Code management: github
+- Memory: knowledge graph storage/recall
+- Files: filesystem read/write
+- Local execution: bash
+- Image generation: stability-ai
+
+## Guidelines
+- Execute tools directly, don't just describe
+- Report errors transparently: "Tool X returned: ..."
+- Acknowledge uncertainty: "Let me verify..."
+- Match user's language (Italian if they use Italian)
+- Be concise and action-oriented
+
+## Tool Format
+<invoke name="TOOL"><parameter name="PARAM">VALUE</parameter></invoke>`;
+/**
+ * Format a tool for the system prompt
+ * With schema: `tool_name(param1: type, param2: type): description`
+ * Without schema: `tool_name: description` or just `tool_name`
+ */
+function formatTool(tool) {
+    if (typeof tool === 'string') {
+        return `- ${tool}`;
+    }
+    const { name, description, inputSchema } = tool;
+    // Build parameter signature if schema available
+    let signature = name;
+    if (inputSchema?.properties) {
+        const params = Object.entries(inputSchema.properties)
+            .map(([key, prop]) => {
+            const required = inputSchema.required?.includes(key) ? '' : '?';
+            return `${key}${required}: ${prop.type || 'any'}`;
+        })
+            .join(', ');
+        if (params) {
+            signature = `${name}(${params})`;
+        }
+    }
+    // Add description if available
+    if (description) {
+        // Truncate long descriptions
+        const shortDesc = description.length > 60
+            ? description.slice(0, 57) + '...'
+            : description;
+        return `- ${signature}: ${shortDesc}`;
+    }
+    return `- ${signature}`;
+}
+/**
+ * Build complete system prompt with dynamically discovered tools
+ *
+ * @param mcpTools - MCP tools by server (with optional schemas)
+ * @param localTools - Local tools (names or definitions)
+ * @param includeSchemas - Whether to include parameter signatures (default: true)
+ */
+async function buildSystemPrompt(mcpTools, localTools, includeSchemas = true) {
+    const parts = [exports.GENESIS_IDENTITY_PROMPT];
+    // Add tool sections
+    parts.push('\n## Available Tools\n');
+    // MCP tools by category
+    if (mcpTools && Object.keys(mcpTools).length > 0) {
+        for (const [server, tools] of Object.entries(mcpTools)) {
+            if (tools.length > 0) {
+                parts.push(`\n### ${server.toUpperCase()}`);
+                for (const tool of tools) {
+                    parts.push(includeSchemas ? formatTool(tool) : `- ${typeof tool === 'string' ? tool : tool.name}`);
+                }
+            }
+        }
+    }
+    // Local tools
+    if (localTools && localTools.length > 0) {
+        parts.push('\n### LOCAL (execute on host)');
+        for (const tool of localTools) {
+            parts.push(includeSchemas ? formatTool(tool) : `- ${typeof tool === 'string' ? tool : tool.name}`);
+        }
+    }
+    return parts.join('\n');
+}
+// Legacy export for backwards compatibility
+exports.GENESIS_SYSTEM_PROMPT = exports.GENESIS_IDENTITY_PROMPT;
+// ============================================================================
+// LLM Bridge Class
+// ============================================================================
+class LLMBridge {
+    config;
+    conversationHistory = [];
+    constructor(config = {}) {
+        // Detect provider first, then use it for model selection
+        const provider = config.provider || this.detectProvider();
+        this.config = {
+            provider,
+            model: config.model || this.defaultModel(provider),
+            apiKey: config.apiKey || this.detectApiKey(provider),
+            temperature: config.temperature ?? 0.7,
+            maxTokens: config.maxTokens ?? 4096,
+        };
+    }
+    detectProvider() {
+        // Priority: Ollama (free) > Anthropic > OpenAI
+        if (process.env.OLLAMA_HOST || process.env.USE_OLLAMA === 'true')
+            return 'ollama';
+        if (process.env.ANTHROPIC_API_KEY)
+            return 'anthropic';
+        if (process.env.OPENAI_API_KEY)
+            return 'openai';
+        return 'ollama'; // Default to local (free)
+    }
+    detectApiKey(provider) {
+        const p = provider || this.config?.provider || this.detectProvider();
+        if (p === 'ollama')
+            return 'not-needed'; // Ollama is local
+        if (p === 'anthropic')
+            return process.env.ANTHROPIC_API_KEY || '';
+        return process.env.OPENAI_API_KEY || '';
+    }
+    defaultModel(provider) {
+        const p = provider || this.config?.provider || 'ollama';
+        if (p === 'ollama')
+            return exports.OLLAMA_CONFIG.defaultModel;
+        if (p === 'anthropic')
+            return 'claude-sonnet-4-20250514';
+        return 'gpt-4o';
+    }
+    /**
+     * Check if Ollama is running
+     */
+    async isOllamaAvailable() {
+        try {
+            const response = await fetch(`${exports.OLLAMA_CONFIG.baseUrl}/api/tags`, {
+                method: 'GET',
+                signal: AbortSignal.timeout(2000),
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Send a message and get a response
+     */
+    async chat(userMessage, systemPrompt) {
+        const system = systemPrompt || exports.GENESIS_SYSTEM_PROMPT;
+        // Add user message to history
+        this.conversationHistory.push({ role: 'user', content: userMessage });
+        const startTime = Date.now();
+        try {
+            let response;
+            if (this.config.provider === 'ollama') {
+                response = await this.callOllama(system);
+            }
+            else if (this.config.provider === 'anthropic') {
+                response = await this.callAnthropic(system);
+            }
+            else {
+                response = await this.callOpenAI(system);
+            }
+            // Add assistant response to history
+            this.conversationHistory.push({ role: 'assistant', content: response.content });
+            return response;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Fallback: if Ollama fails, try cloud
+            if (this.config.provider === 'ollama' && process.env.OPENAI_API_KEY) {
+                console.log('[LLM] Ollama unavailable, falling back to OpenAI...');
+                this.config.provider = 'openai';
+                this.config.apiKey = process.env.OPENAI_API_KEY;
+                this.config.model = 'gpt-4o';
+                return this.chat(userMessage, systemPrompt);
+            }
+            throw new Error(`LLM call failed: ${errorMessage}`);
+        }
+    }
+    /**
+     * Call OpenAI API
+     */
+    async callOpenAI(systemPrompt) {
+        const startTime = Date.now();
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            ...this.conversationHistory,
+        ];
+        const response = await fetch('https://api.openai.com/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.config.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: this.config.model,
+                messages,
+                temperature: this.config.temperature,
+                max_tokens: this.config.maxTokens,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        return {
+            content: data.choices[0]?.message?.content || '',
+            model: this.config.model,
+            provider: 'openai',
+            usage: {
+                inputTokens: data.usage?.prompt_tokens || 0,
+                outputTokens: data.usage?.completion_tokens || 0,
+            },
+            latency: Date.now() - startTime,
+        };
+    }
+    /**
+     * Call Anthropic API
+     */
+    async callAnthropic(systemPrompt) {
+        const startTime = Date.now();
+        const response = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.config.apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify({
+                model: this.config.model,
+                max_tokens: this.config.maxTokens,
+                system: systemPrompt,
+                messages: this.conversationHistory.map(m => ({
+                    role: m.role === 'system' ? 'user' : m.role,
+                    content: m.content,
+                })),
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        return {
+            content: data.content[0]?.text || '',
+            model: this.config.model,
+            provider: 'anthropic',
+            usage: {
+                inputTokens: data.usage?.input_tokens || 0,
+                outputTokens: data.usage?.output_tokens || 0,
+            },
+            latency: Date.now() - startTime,
+        };
+    }
+    /**
+     * Call Ollama API (local, free)
+     * Uses OpenAI-compatible endpoint for easy switching
+     */
+    async callOllama(systemPrompt) {
+        const startTime = Date.now();
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            ...this.conversationHistory,
+        ];
+        const response = await fetch(`${exports.OLLAMA_CONFIG.baseUrl}/api/chat`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this.config.model,
+                messages,
+                stream: false,
+                options: {
+                    temperature: this.config.temperature,
+                    num_predict: this.config.maxTokens,
+                },
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Ollama API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        return {
+            content: data.message?.content || '',
+            model: this.config.model,
+            provider: 'ollama',
+            usage: {
+                inputTokens: data.prompt_eval_count || 0,
+                outputTokens: data.eval_count || 0,
+            },
+            latency: Date.now() - startTime,
+        };
+    }
+    /**
+     * Clear conversation history
+     */
+    clearHistory() {
+        this.conversationHistory = [];
+    }
+    /**
+     * Get conversation history
+     */
+    getHistory() {
+        return [...this.conversationHistory];
+    }
+    /**
+     * Get current config
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Check if API key is configured (or Ollama available)
+     */
+    isConfigured() {
+        if (this.config.provider === 'ollama')
+            return true; // Local, no key needed
+        return !!this.config.apiKey;
+    }
+    /**
+     * Get provider status
+     */
+    status() {
+        return {
+            configured: this.isConfigured(),
+            provider: this.config.provider,
+            model: this.config.model,
+            isLocal: this.config.provider === 'ollama',
+        };
+    }
+    /**
+     * List available Ollama models
+     */
+    async listOllamaModels() {
+        try {
+            const response = await fetch(`${exports.OLLAMA_CONFIG.baseUrl}/api/tags`);
+            if (!response.ok)
+                return [];
+            const data = await response.json();
+            return data.models?.map((m) => m.name) || [];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.LLMBridge = LLMBridge;
+// ============================================================================
+// Factory & Singleton
+// ============================================================================
+let llmBridgeInstance = null;
+function createLLMBridge(config) {
+    return new LLMBridge(config);
+}
+function getLLMBridge(config) {
+    if (!llmBridgeInstance) {
+        llmBridgeInstance = createLLMBridge(config);
+    }
+    return llmBridgeInstance;
+}
+function resetLLMBridge() {
+    llmBridgeInstance = null;
+}

package/dist/src/llm/router.d.ts

@@ -0,0 +1,136 @@
+/**
+ * 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
+ */
+import { LLMProvider, LLMResponse } from './index.js';
+export interface HardwareProfile {
+    /** Detected CPU type */
+    cpu: string;
+    /** Is Apple Silicon (M1/M2/M3/M4)? */
+    isAppleSilicon: boolean;
+    /** CPU cores */
+    cores: number;
+    /** Total memory in GB */
+    memoryGB: number;
+    /** Performance tier: low, medium, high, ultra */
+    tier: 'low' | 'medium' | 'high' | 'ultra';
+    /** Recommended cloud threshold */
+    recommendedThreshold: TaskComplexity;
+    /** Recommended max tokens */
+    recommendedMaxTokens: number;
+}
+/**
+ * Detect hardware capabilities and recommend router config
+ */
+export declare function detectHardware(): HardwareProfile;
+export type TaskComplexity = 'trivial' | 'simple' | 'moderate' | 'complex' | 'creative';
+export interface RoutingDecision {
+    /** Selected provider */
+    provider: LLMProvider;
+    /** Reasoning for the decision */
+    reason: string;
+    /** Estimated complexity */
+    complexity: TaskComplexity;
+    /** Confidence in decision (0-1) */
+    confidence: number;
+    /** Estimated tokens */
+    estimatedTokens: number;
+    /** Estimated cost (USD) for cloud */
+    estimatedCost: number;
+    /** Should we try local first? */
+    tryLocalFirst: boolean;
+}
+export interface RouterConfig {
+    /** Prefer local for all tasks (cost optimization) */
+    preferLocal: boolean;
+    /** Force cloud for all tasks (quality optimization) */
+    forceCloud: boolean;
+    /** Maximum tokens for local model */
+    localMaxTokens: number;
+    /** Complexity threshold for cloud (trivial=0, creative=4) */
+    cloudThreshold: TaskComplexity;
+    /** Auto-fallback to cloud if local fails */
+    autoFallback: boolean;
+    /** Log routing decisions */
+    logDecisions: boolean;
+}
+export interface RouterStats {
+    totalRequests: number;
+    localRequests: number;
+    cloudRequests: number;
+    fallbacks: number;
+    avgLocalLatency: number;
+    avgCloudLatency: number;
+    estimatedSavings: number;
+}
+/**
+ * Analyze task complexity from the prompt
+ */
+export declare function analyzeComplexity(prompt: string): {
+    complexity: TaskComplexity;
+    confidence: number;
+    indicators: string[];
+};
+/**
+ * Estimate token count from prompt
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * Estimate cost for cloud provider
+ */
+export declare function estimateCost(inputTokens: number, outputTokens: number, provider: LLMProvider): number;
+export declare class HybridRouter {
+    private config;
+    private stats;
+    private localBridge;
+    private cloudBridge;
+    private hardwareProfile;
+    constructor(config?: Partial<RouterConfig>);
+    /**
+     * Get detected hardware profile
+     */
+    getHardwareProfile(): HardwareProfile;
+    /**
+     * Decide which provider to use
+     */
+    route(prompt: string): Promise<RoutingDecision>;
+    /**
+     * Execute request with routing
+     */
+    execute(prompt: string, systemPrompt?: string): Promise<LLMResponse & {
+        routingDecision: RoutingDecision;
+    }>;
+    private isOllamaAvailable;
+    private getBridge;
+    private updateAverage;
+    getStats(): RouterStats;
+    resetStats(): void;
+    getConfig(): RouterConfig;
+    setConfig(config: Partial<RouterConfig>): void;
+}
+export declare function getHybridRouter(config?: Partial<RouterConfig>): HybridRouter;
+export declare function resetHybridRouter(): void;
+/**
+ * Smart chat: automatically routes to best provider
+ */
+export declare function smartChat(prompt: string, systemPrompt?: string): Promise<LLMResponse>;
+/**
+ * Force local chat (Ollama)
+ */
+export declare function localChat(prompt: string, systemPrompt?: string): Promise<LLMResponse>;
+/**
+ * Force cloud chat
+ */
+export declare function cloudChat(prompt: string, systemPrompt?: string): Promise<LLMResponse>;