@decido/kernel-bridge 1.0.0

package/src/ai/services/EmbeddingService.ts

@@ -0,0 +1,119 @@
+/**
+ * EmbeddingService — Local text embeddings for RAG pipeline
+ * 
+ * Generates vector embeddings from text using:
+ *  1. Ollama embeddings API (nomic-embed-text)
+ *  2. Simple TF-IDF fallback for offline use
+ * 
+ * Used by VectorStore for semantic similarity search.
+ */
+
+// ─── Types ───────────────────────────────────────────────────
+
+export interface EmbeddingResult {
+    vector: number[];
+    dimensions: number;
+    model: string;
+    latencyMs: number;
+}
+
+export type EmbeddingBackend = 'ollama' | 'tfidf';
+
+// ─── Constants ───────────────────────────────────────────────
+
+const OLLAMA_URL = 'http://localhost:11434';
+const EMBED_MODEL = 'nomic-embed-text';
+const TFIDF_DIMS = 256;
+
+// ─── Ollama Embeddings ───────────────────────────────────────
+
+async function ollamaEmbed(text: string): Promise<EmbeddingResult> {
+    const start = Date.now();
+    try {
+        const res = await fetch(`${OLLAMA_URL}/api/embed`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ model: EMBED_MODEL, input: text }),
+        });
+        if (!res.ok) throw new Error(`Ollama embed failed: ${res.status}`);
+        const data = await res.json();
+        const vector = data.embeddings?.[0] || data.embedding || [];
+        return {
+            vector,
+            dimensions: vector.length,
+            model: EMBED_MODEL,
+            latencyMs: Date.now() - start,
+        };
+    } catch (err) {
+        console.warn('[EmbeddingService] Ollama not available, falling back to TF-IDF', err);
+        return tfidfEmbed(text);
+    }
+}
+
+// ─── TF-IDF Fallback ─────────────────────────────────────────
+
+/** Simple hash-based embedding for offline use */
+function tfidfEmbed(text: string): EmbeddingResult {
+    const start = Date.now();
+    const tokens = text.toLowerCase()
+        .replace(/[^\w\s]/g, '')
+        .split(/\s+/)
+        .filter(t => t.length > 2);
+
+    const vector = new Array(TFIDF_DIMS).fill(0);
+
+    for (const token of tokens) {
+        let hash = 0;
+        for (let i = 0; i < token.length; i++) {
+            hash = ((hash << 5) - hash + token.charCodeAt(i)) | 0;
+        }
+        const idx = Math.abs(hash) % TFIDF_DIMS;
+        vector[idx] += 1.0 / tokens.length;
+    }
+
+    // L2 normalize
+    const norm = Math.sqrt(vector.reduce((s: number, v: number) => s + v * v, 0));
+    if (norm > 0) {
+        for (let i = 0; i < vector.length; i++) vector[i] /= norm;
+    }
+
+    return {
+        vector,
+        dimensions: TFIDF_DIMS,
+        model: 'tfidf-fallback',
+        latencyMs: Date.now() - start,
+    };
+}
+
+// ─── Public API ──────────────────────────────────────────────
+
+let preferredBackend: EmbeddingBackend = 'ollama';
+
+export async function embed(text: string): Promise<EmbeddingResult> {
+    if (preferredBackend === 'ollama') {
+        return ollamaEmbed(text);
+    }
+    return tfidfEmbed(text);
+}
+
+export async function embedBatch(texts: string[]): Promise<EmbeddingResult[]> {
+    return Promise.all(texts.map(t => embed(t)));
+}
+
+export function setBackend(backend: EmbeddingBackend): void {
+    preferredBackend = backend;
+}
+
+export function cosineSimilarity(a: number[], b: number[]): number {
+    if (a.length !== b.length) return 0;
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom === 0 ? 0 : dot / denom;
+}
+
+export const embeddingService = { embed, embedBatch, setBackend, cosineSimilarity };

package/src/ai/services/InferenceRouter.ts

@@ -0,0 +1,347 @@
+/**
+ * InferenceRouter — Multi-backend AI inference routing
+ * 
+ * Routes prompts to the optimal backend based on:
+ *  - Provider availability (Ollama local → Gemini API → fallback)
+ *  - Active provider setting from user config
+ *  - Automatic fallback chain
+ * 
+ * Providers:
+ *  1. Ollama (local, fast, tool-calling via Qwen2)
+ *  2. Gemini (Google API, powerful, requires API key)
+ *  3. MLX (local, Apple Silicon optimized)
+ */
+
+import {
+    registerProvider,
+    getProvider,
+    getAllProviders,
+    type LLMProvider,
+    type ChatMessage,
+    type ChatResult,
+    type ProviderStatus,
+} from './providers/LLMProvider';
+import { OllamaProvider } from './providers/OllamaProvider';
+import { GeminiProvider } from './providers/GeminiProvider';
+import { AnthropicProvider } from './providers/AnthropicProvider';
+import { OpenAIProvider } from './providers/OpenAIProvider';
+import { tokenWallet } from './TokenWallet';
+
+// Re-export for consumers
+export { getAllProviders, type LLMProvider, type ProviderStatus };
+
+// ─── Types ───────────────────────────────────────────────────
+
+export type InferenceBackend = 'ollama' | 'gemini' | 'anthropic' | 'openai' | 'mlx' | 'auto';
+
+export type TaskType = 'tool-calling' | 'chat' | 'code' | 'analysis' | 'creative';
+
+export interface RouterConfig {
+    preferredBackend: InferenceBackend;
+    maxLatencyMs: number;
+    enableFallback: boolean;
+    temperature: number;
+    maxTokens: number;
+}
+
+export interface RoutedResponse {
+    text: string;
+    backend: InferenceBackend;
+    model: string;
+    latencyMs: number;
+    tokensPerSecond: number;
+    toolsInvoked: string[];
+}
+
+// ─── Default Config ──────────────────────────────────────────
+
+const DEFAULT_CONFIG: RouterConfig = {
+    preferredBackend: 'auto',
+    maxLatencyMs: 30000,
+    enableFallback: true,
+    temperature: 0.7,
+    maxTokens: 512,
+};
+
+// ─── Provider Initialization ─────────────────────────────────
+
+let _initialized = false;
+
+function ensureProviders(): void {
+    if (_initialized) return;
+    _initialized = true;
+
+    registerProvider(new OllamaProvider());
+    registerProvider(new GeminiProvider());
+    registerProvider(new AnthropicProvider());
+    registerProvider(new OpenAIProvider());
+
+    console.log('🔌 [InferenceRouter] 4 providers initialized (Ollama, Gemini, Anthropic, OpenAI)');
+}
+
+// ─── API Key Management ─────────────────────────────────────
+
+interface ProviderKeys {
+    gemini?: string;
+    openai?: string;
+    anthropic?: string;
+    [key: string]: string | undefined;
+}
+
+let _cachedKeys: ProviderKeys | null = null;
+
+async function getInvoke(): Promise<((cmd: string, args?: Record<string, unknown>) => Promise<unknown>) | null> {
+    try {
+        const tauri = await import('@tauri-apps/api/core');
+        return tauri.invoke;
+    } catch {
+        return null;
+    }
+}
+
+export async function loadProviderKeys(): Promise<ProviderKeys> {
+    if (_cachedKeys) return _cachedKeys;
+
+    try {
+        const invoke = await getInvoke();
+        if (invoke) {
+            const raw = await invoke('load_provider_keys') as string | null;
+            if (raw) {
+                _cachedKeys = JSON.parse(raw);
+                return _cachedKeys!;
+            }
+        }
+    } catch (e) {
+        console.warn('[InferenceRouter] Failed to load provider keys:', e);
+    }
+
+    // Fallback to localStorage
+    try {
+        const stored = localStorage.getItem('macia-provider-keys');
+        if (stored) {
+            _cachedKeys = JSON.parse(stored);
+            return _cachedKeys!;
+        }
+    } catch { /* ignore */ }
+
+    _cachedKeys = {};
+    return _cachedKeys;
+}
+
+export async function saveProviderKeys(keys: ProviderKeys): Promise<void> {
+    _cachedKeys = keys;
+
+    try {
+        const invoke = await getInvoke();
+        if (invoke) {
+            await invoke('save_provider_keys', {
+                json: JSON.stringify(keys, null, 2),
+            });
+            return;
+        }
+    } catch (e) {
+        console.warn('[InferenceRouter] Failed to save provider keys via Tauri:', e);
+    }
+
+    // Fallback to localStorage
+    try {
+        localStorage.setItem('macia-provider-keys', JSON.stringify(keys));
+    } catch { /* ignore */ }
+}
+
+/**
+ * Initialize providers and load saved API keys.
+ * Call once during app bootstrap.
+ */
+export async function initProviders(): Promise<void> {
+    ensureProviders();
+
+    const keys = await loadProviderKeys();
+
+    // Apply saved keys to all providers
+    const providerKeyMap: Record<string, string | undefined> = {
+        gemini: keys.gemini,
+        anthropic: keys.anthropic,
+        openai: keys.openai,
+    };
+
+    for (const [id, key] of Object.entries(providerKeyMap)) {
+        if (key) {
+            const provider = getProvider(id);
+            provider?.setApiKey?.(key);
+            console.log(`🔑 [InferenceRouter] ${id} API key loaded`);
+        }
+    }
+}
+
+/**
+ * Set/update an API key for a provider and persist it.
+ */
+export async function setProviderApiKey(providerId: string, apiKey: string): Promise<void> {
+    const provider = getProvider(providerId);
+    if (provider?.setApiKey) {
+        provider.setApiKey(apiKey);
+    }
+
+    const keys = await loadProviderKeys();
+    keys[providerId] = apiKey;
+    await saveProviderKeys(keys);
+}
+
+// ─── Provider Status ─────────────────────────────────────────
+
+export async function getProviderStatuses(): Promise<Record<string, ProviderStatus>> {
+    ensureProviders();
+    const statuses: Record<string, ProviderStatus> = {};
+    for (const provider of getAllProviders()) {
+        statuses[provider.id] = await provider.checkStatus();
+    }
+    return statuses;
+}
+
+// ─── Task Classifier ─────────────────────────────────────────
+
+function classifyTask(prompt: string): TaskType {
+    const lower = prompt.toLowerCase();
+
+    const toolPatterns = [
+        'ejecuta', 'revisa', 'escanea', 'limpia', 'optimiza',
+        'monitorea', 'diagnostica', 'analiza el sistema',
+        'procesos', 'disco', 'memoria', 'red', 'seguridad',
+        'git', 'commit', 'deploy', 'backup',
+    ];
+    if (toolPatterns.some(p => lower.includes(p))) return 'tool-calling';
+
+    const codePatterns = ['codigo', 'funcion', 'clase', 'error', 'debug', 'refactor', 'typescript', 'python', 'rust'];
+    if (codePatterns.some(p => lower.includes(p))) return 'code';
+
+    const analysisPatterns = ['analiza', 'compara', 'benchmark', 'rendimiento', 'metricas', 'estadisticas'];
+    if (analysisPatterns.some(p => lower.includes(p))) return 'analysis';
+
+    const creativePatterns = ['genera', 'crea', 'escribe', 'inventa', 'imagina', 'diseña'];
+    if (creativePatterns.some(p => lower.includes(p))) return 'creative';
+
+    return 'chat';
+}
+
+// ─── Main Router ─────────────────────────────────────────────
+
+/**
+ * Route a chat request to the best available provider.
+ * 
+ * This is the main entry point used by OllamaService and AgentToolLoop.
+ */
+export async function routeChat(
+    messages: ChatMessage[],
+    config: Partial<RouterConfig> = {},
+): Promise<ChatResult & { backend: string }> {
+    ensureProviders();
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+
+    // Determine which provider to try
+    const providerOrder = resolveProviderOrder(cfg.preferredBackend);
+
+    for (const providerId of providerOrder) {
+        const provider = getProvider(providerId);
+        if (!provider) continue;
+
+        const status = await provider.checkStatus();
+        if (status !== 'available') {
+            if (!cfg.enableFallback) {
+                throw new Error(`Provider ${provider.name} is ${status}`);
+            }
+            continue;
+        }
+
+        try {
+            const result = await provider.chat(messages, {
+                model: undefined, // use provider default
+                temperature: cfg.temperature,
+                maxTokens: cfg.maxTokens,
+            });
+
+            // 💰 Record usage in Token Wallet
+            tokenWallet.record({
+                provider: providerId,
+                model: result.model,
+                tokensUsed: result.tokensUsed,
+            });
+
+            return {
+                ...result,
+                backend: providerId,
+            };
+        } catch (err) {
+            console.warn(`[InferenceRouter] ${provider.name} failed:`, err);
+            if (!cfg.enableFallback) throw err;
+            // Try next provider
+        }
+    }
+
+    throw new Error('No hay backends de IA disponibles. Inicia Ollama o configura una API key de Gemini.');
+}
+
+function resolveProviderOrder(preferred: InferenceBackend): string[] {
+    switch (preferred) {
+        case 'ollama': return ['ollama', 'gemini', 'anthropic', 'openai'];
+        case 'gemini': return ['gemini', 'ollama', 'anthropic', 'openai'];
+        case 'anthropic': return ['anthropic', 'gemini', 'ollama', 'openai'];
+        case 'openai': return ['openai', 'gemini', 'ollama', 'anthropic'];
+        case 'auto':
+        default:
+            return ['ollama', 'gemini', 'anthropic', 'openai'];
+    }
+}
+
+// ─── Legacy API Compatibility ────────────────────────────────
+
+/**
+ * Legacy `routeInference` function — routes a prompt string.
+ * Used by AgentLoop, AgentPlanner, RAGPipeline.
+ */
+export async function routeInference(
+    prompt: string,
+    config: Partial<RouterConfig> = {},
+): Promise<RoutedResponse> {
+    const messages: ChatMessage[] = [
+        { role: 'user', content: prompt },
+    ];
+
+    try {
+        const result = await routeChat(messages, config);
+        return {
+            text: result.text,
+            backend: result.backend as InferenceBackend,
+            model: result.model,
+            latencyMs: result.latencyMs,
+            tokensPerSecond: result.tokensUsed
+                ? result.tokensUsed / (result.latencyMs / 1000)
+                : 0,
+            toolsInvoked: [],
+        };
+    } catch {
+        return {
+            text: 'No hay backends disponibles. Inicia Ollama o configura un modelo.',
+            backend: 'auto',
+            model: 'none',
+            latencyMs: 0,
+            tokensPerSecond: 0,
+            toolsInvoked: [],
+        };
+    }
+}
+
+// ─── Convenience Export ──────────────────────────────────────
+
+export const inferenceRouter = {
+    route: routeInference,
+    routeChat,
+    classifyTask,
+    initProviders,
+    getProviderStatuses,
+    setProviderApiKey,
+    loadProviderKeys,
+    getAllProviders,
+    getProvider,
+    tokenWallet,
+};

package/src/ai/services/LocalAgentResponder.ts

@@ -0,0 +1,199 @@
+/**
+ * LocalAgentResponder — Local-first AI responses for DecidoOS
+ * 
+ * Handles user input locally when Cortex is not connected.
+ * Provides greeting responses, tool execution, system info queries,
+ * and basic conversational ability without requiring a remote AI.
+ */
+
+
+// ─── Types ──────────────────────────────────────────────────
+
+interface LocalResponse {
+    text: string;
+    toolCalls?: Array<{ name: string; args: Record<string, unknown> }>;
+}
+
+// ─── Greeting Patterns ──────────────────────────────────────
+
+const GREETING_PATTERNS = [
+    /^(hola|hey|hi|hello|buenas|qué tal|que tal|saludos)\s*(decido|decidoos|agente|asistente)?/i,
+    /^(buenos?\s*(días|tardes|noches))/i,
+    /^(órale|oye|ey)\s*(decido)?/i,
+];
+
+const HELP_PATTERNS = [
+    /^(ayuda|help|qué puedes hacer|que puedes hacer|comandos|tools|herramientas)/i,
+    /^(qué|que)\s*(sabes|haces|puedes)/i,
+];
+
+const SYSTEM_PATTERNS = [
+    /^(estado|status|sistema|system)\s*(del\s*sistema)?/i,
+    /^(cómo|como)\s*(estás|estas|está|va)/i,
+];
+
+// ─── Response Templates ─────────────────────────────────────
+
+function getTimeGreeting(): string {
+    const hour = new Date().getHours();
+    if (hour < 12) return 'Buenos días';
+    if (hour < 18) return 'Buenas tardes';
+    return 'Buenas noches';
+}
+
+function getWelcomeMessage(): string {
+    const greeting = getTimeGreeting();
+
+    return `${greeting}, operador. Soy **DecidoOS Agent** 🧠
+
+Estoy en línea y operativo. Aquí está mi reporte de estado:
+
+▸ **Modo**: Local-first (sin dependencia de Cortex)
+▸ **Estado**: ✅ ONLINE
+
+Puedo auditar tu seguridad, escanear tu flota de procesos y más.
+
+Escribe **"ayuda"** para ver mis comandos principales.`;
+}
+
+function getHelpMessage(): string {
+    return `🛠️ **Capacidades de DecidoOS Agent**
+
+• "escanea puertos" — Auditar puertos abiertos
+• "escanea red" — Monitorear conexiones de red
+• "escanea flota" — Ver procesos Agent / Node / Python
+• "lista tareas" — Ver tareas / playbooks
+• "estado" — Estado del sistema
+
+**Voice Mode:**
+Presiona el botón verde 📞 para activar conversación por voz con Cortex.`;
+}
+
+async function getSystemStatus(): Promise<string> {
+    let cpuInfo = 'N/A';
+    let memInfo = 'N/A';
+
+    try {
+        const { invoke } = await import('@tauri-apps/api/core');
+        const cpu = await invoke<{ usage: number }>('get_cpu_usage');
+        const mem = await invoke<{ used: number; total: number }>('get_memory_usage');
+        cpuInfo = `${cpu.usage?.toFixed(1)}%`;
+        memInfo = `${(mem.used / 1024 / 1024 / 1024).toFixed(1)} GB / ${(mem.total / 1024 / 1024 / 1024).toFixed(1)} GB`;
+    } catch {
+        cpuInfo = '(requiere Tauri)';
+        memInfo = '(requiere Tauri)';
+    }
+
+    return `📊 **Estado del Sistema DecidoOS**
+
+▸ **CPU**: ${cpuInfo}
+▸ **RAM**: ${memInfo}
+▸ **Cortex**: Local mode
+▸ **Uptime Session**: ${getSessionUptime()}
+
+Todo operativo. ¿Necesitas algo más?`;
+}
+
+function getSessionUptime(): string {
+    const uptime = performance.now();
+    const minutes = Math.floor(uptime / 60000);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) return `${hours}h ${minutes % 60}m`;
+    return `${minutes}m`;
+}
+
+// ─── Main Responder ─────────────────────────────────────────
+
+export async function processLocalMessage(input: string): Promise<LocalResponse> {
+    const trimmed = input.trim();
+
+    // 1. Greeting
+    if (GREETING_PATTERNS.some(p => p.test(trimmed))) {
+        return { text: getWelcomeMessage() };
+    }
+
+    // 2. Help
+    if (HELP_PATTERNS.some(p => p.test(trimmed))) {
+        return { text: getHelpMessage() };
+    }
+
+    // 3. System status
+    if (SYSTEM_PATTERNS.some(p => p.test(trimmed))) {
+        const status = await getSystemStatus();
+        return { text: status };
+    }
+
+    // 4. Tool execution patterns
+    const execMatch = trimmed.match(/^(ejecuta|run|exec|corre)\s+(.+)/i);
+    if (execMatch) {
+        const command = execMatch[2];
+        return {
+            text: `⚡ Ejecutando: \`${command}\`...`,
+            toolCalls: [{ name: 'tactical.execute_command', args: { command } }],
+        };
+    }
+
+    const scanMatch = trimmed.match(/^(escanea|scan|audita|audit)\s*(puertos|ports)/i);
+    if (scanMatch) {
+        return {
+            text: '🔍 Escaneando puertos del sistema...',
+            toolCalls: [{ name: 'security.audit_ports', args: { includeLoopback: false } }],
+        };
+    }
+
+    const networkMatch = trimmed.match(/^(escanea|scan|monitorea|monitor)\s*(red|network|conexiones|connections)/i);
+    if (networkMatch) {
+        return {
+            text: '🌐 Analizando conexiones de red...',
+            toolCalls: [{ name: 'security.network_monitor', args: {} }],
+        };
+    }
+
+    const fleetMatch = trimmed.match(/^(escanea|scan)\s*(flota|fleet|procesos|processes)/i);
+    if (fleetMatch) {
+        return {
+            text: '🛸 Escaneando flotilla de agentes...',
+            toolCalls: [{ name: 'tactical.scan_fleet', args: {} }],
+        };
+    }
+
+    const listMatch = trimmed.match(/^(lista|list|muestra|show)\s*(tareas|tasks|playbooks)/i);
+    if (listMatch) {
+        return {
+            text: '📋 Listando tareas...',
+            toolCalls: [{ name: 'tactical.list_tasks', args: { status: 'all' } }],
+        };
+    }
+
+    // 5. Forensic scan
+    const forensicMatch = trimmed.match(/^(analiza|analyze|forense|forensic)\s*(proceso|process)?\s*(\d+)?/i);
+    if (forensicMatch) {
+        const pid = forensicMatch[3] ? parseInt(forensicMatch[3]) : undefined;
+        return {
+            text: pid ? `🔬 Analizando proceso PID ${pid}...` : '🔬 Escaneando procesos sospechosos...',
+            toolCalls: [{ name: 'security.forensic_scan', args: { pid, deep: true } }],
+        };
+    }
+
+    // 6. Vulnerability scan
+    const vulnMatch = trimmed.match(/^(vulnerabilidades|vulnerabilities|vuln|audit\s*npm)/i);
+    if (vulnMatch) {
+        return {
+            text: '🛡️ Escaneando vulnerabilidades en dependencias...',
+            toolCalls: [{ name: 'security.scan_vulnerabilities', args: {} }],
+        };
+    }
+
+    // 7. Default - unrecognized
+    return {
+        text: `🤖 Entendido: "${trimmed.slice(0, 100)}"
+
+No tengo una respuesta local para esto. Para respuestas inteligentes con IA, conecta a **Cortex** (mindframe-cortex).
+
+Mientras tanto, prueba:
+• "ayuda" — ver mis capacidades
+• "ejecuta ls" — ejecutar un comando
+• "escanea puertos" — auditar seguridad
+• "estado" — ver estado del sistema`,
+    };
+}