@decido/kernel-bridge 1.0.0 → 4.0.2

package/src/ai/services/OllamaService.ts

@@ -1,326 +0,0 @@
-/**
- * OllamaService — Chat interface for DecidoOS Agent
- * 
- * Manages conversation history, system prompt construction,
- * and tool-call parsing. Chat requests are now routed through
- * InferenceRouter to support multiple LLM providers.
- */
-
-import { routeChat } from './InferenceRouter';
-import type { ChatMessage } from './providers/LLMProvider';
-
-// ─── Types ──────────────────────────────────────────────────
-
-interface OllamaChatMessage {
-    role: 'system' | 'user' | 'assistant';
-    content: string;
-}
-
-interface OllamaModelInfo {
-    name: string;
-    size: number;
-    modified_at: string;
-}
-
-// ─── Tool Call Types ────────────────────────────────────────
-
-export interface ToolCallRequest {
-    name: string;
-    args: Record<string, unknown>;
-}
-
-export interface ChatWithToolsResult {
-    text: string;
-    toolCalls: ToolCallRequest[];
-}
-
-// ─── Config ─────────────────────────────────────────────────
-
-const OLLAMA_BASE_URL = 'http://localhost:11434';
-const DEFAULT_MODEL = 'qwen2:latest';
-
-// ─── System Prompt ──────────────────────────────────────────
-
-function buildSystemPrompt(): string {
-    const liveContext = buildLiveContext();
-    const toolSchemas = ''; // Removed toolRegistry reference to fix dependencies, but kept variable for now
-
-    return `- Estás integrado en DecidoOS, una plataforma empresarial de escritorio
-- Corres localmente en la máquina del usuario — todo es privado
-- Puedes ejecutar herramientas del sistema para ayudar al usuario
-
-${liveContext}
-
-## Herramientas disponibles
-
-${toolSchemas}
-
-## Reglas de respuesta
-1. Responde siempre en español a menos que el usuario hable en otro idioma
-2. Sé directo — no des introducciones largas
-3. Si puedes resolver algo con una herramienta, USA LA HERRAMIENTA nativa en vez de solo describirla
-4. Mantén respuestas bajo 300 palabras
-5. Si no sabes algo, dilo honestamente
-6. NO inventes resultados de herramientas — espera el resultado real
-7. Cuando el usuario pregunte sobre el estado del sistema, USA LOS DATOS del "Estado actual del sistema" que tienes arriba — esos son datos reales y recientes`;
-}
-
-// ─── Live Context Builder ───────────────────────────────────
-
-/**
- * Builds a live system context section from watchdog metrics
- * and the app's context snapshot. Called every time a message
- * is sent to keep the LLM's awareness current.
- */
-function buildLiveContext(): string {
-    const parts: string[] = ['## Estado actual del sistema'];
-    const now = new Date().toLocaleString('es-CO', { hour12: false });
-    parts.push(`Hora actual: ${now}`);
-
-    // Watchdog metrics
-    try {
-        // Dynamic import to avoid circular deps — we access synchronously via singleton
-        const watchdogModule = (globalThis as any).__systemWatchdog;
-        if (watchdogModule) {
-            const snapshot = watchdogModule.getLastSnapshot?.();
-            if (snapshot) {
-                const metrics: string[] = [];
-                if (snapshot.cpuPercent !== null) metrics.push(`CPU: ${snapshot.cpuPercent.toFixed(1)}%`);
-                if (snapshot.memoryPercent !== null) metrics.push(`Memoria: ${snapshot.memoryPercent.toFixed(1)}%`);
-                if (snapshot.diskFreeGB !== null) metrics.push(`Disco libre: ${snapshot.diskFreeGB.toFixed(1)} GB`);
-                if (snapshot.connectionCount !== null) metrics.push(`Conexiones de red: ${snapshot.connectionCount}`);
-                if (metrics.length > 0) {
-                    parts.push(`Métricas del sistema: ${metrics.join(' | ')}`);
-                }
-            }
-
-            const alerts = watchdogModule.getAlerts?.()?.filter((a: any) => !a.dismissed).slice(-5) ?? [];
-            if (alerts.length > 0) {
-                parts.push('Alertas recientes:');
-                for (const alert of alerts) {
-                    const emoji = alert.severity === 'critical' ? '🚨' : '⚠️';
-                    parts.push(`  ${emoji} ${alert.title}`);
-                }
-            }
-        }
-    } catch {
-        // Watchdog not available yet
-    }
-
-    // Context snapshot from store (accessed via globalThis to avoid monolith coupling)
-    try {
-        const appStore = (globalThis as any).__appStore;
-        const ctx = appStore?.getState?.()?.contextSnapshot;
-        if (ctx) {
-            if (ctx.canvasNodeCount > 0) parts.push(`Canvas: ${ctx.canvasNodeCount} nodos`);
-            if (ctx.gitBranch) parts.push(`Git: rama ${ctx.gitBranch}${ctx.gitModifiedFiles ? ` (${ctx.gitModifiedFiles} archivos modificados)` : ''}`);
-            if (ctx.activeInsights > 0) parts.push(`Insights activos: ${ctx.activeInsights}`);
-            if (ctx.criticalInsightsSummary?.length > 0) {
-                parts.push('Insights críticos: ' + ctx.criticalInsightsSummary.slice(0, 3).join('; '));
-            }
-        }
-    } catch {
-        // Store not available
-    }
-
-    // Persistent memory (learned facts)
-    try {
-        const memoryModule = (globalThis as any).__agentMemory;
-        if (memoryModule) {
-            const memContext = memoryModule.buildMemoryContext?.();
-            if (memContext) {
-                parts.push('');
-                parts.push(memContext);
-            }
-        }
-    } catch {
-        // Memory not available
-    }
-
-    return parts.join('\n');
-}
-
-// ─── Tool Call Parser ───────────────────────────────────────
-
-/**
- * Parse Ollama native tool calls from the message object.
- * Previously this used a Regex over the text response.
- */
-export function parseToolCalls(message: any): ToolCallRequest[] {
-    const calls: ToolCallRequest[] = [];
-
-    if (message?.tool_calls && Array.isArray(message.tool_calls)) {
-        for (const tc of message.tool_calls) {
-            if (tc.function?.name) {
-                calls.push({
-                    name: tc.function.name,
-                    args: tc.function.arguments || {},
-                });
-            }
-        }
-    }
-
-    return calls;
-}
-
-/**
- * Strip tool_call blocks from text to get the clean message.
- * Using native tools, this is usually a no-op as tools are not in the text,
- * but kept for backwards compatibility with any leaked formatting.
- */
-export function stripToolCalls(text: string): string {
-    if (!text) return '';
-    return text.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, '').trim();
-}
-
-// ─── Conversation History ───────────────────────────────────
-
-let conversationHistory: OllamaChatMessage[] = [];
-const MAX_HISTORY = 20;
-
-function addToHistory(msg: OllamaChatMessage): void {
-    conversationHistory.push(msg);
-    if (conversationHistory.length > MAX_HISTORY) {
-        conversationHistory = conversationHistory.slice(-MAX_HISTORY);
-    }
-}
-
-export function clearConversationHistory(): void {
-    conversationHistory = [];
-}
-
-// ─── API Methods ────────────────────────────────────────────
-
-/**
- * Check if Ollama is running and accessible.
- */
-export async function isOllamaAvailable(): Promise<boolean> {
-    try {
-        const res = await fetch(`${OLLAMA_BASE_URL}/api/tags`, {
-            signal: AbortSignal.timeout(2000)
-        });
-        return res.ok;
-    } catch {
-        return false;
-    }
-}
-
-/**
- * List available models from Ollama.
- */
-export async function listModels(): Promise<string[]> {
-    try {
-        const res = await fetch(`${OLLAMA_BASE_URL}/api/tags`);
-        if (!res.ok) return [];
-        const data = await res.json();
-        return (data.models || []).map((m: OllamaModelInfo) => m.name);
-    } catch {
-        return [];
-    }
-}
-
-/**
- * Send a chat message and get a complete response (non-streaming).
- * Routes through InferenceRouter to support multiple providers.
- */
-export async function chat(
-    userMessage: string,
-    options?: { model?: string; temperature?: number }
-): Promise<string> {
-    const userMsg: ChatMessage = { role: 'user', content: userMessage };
-    addToHistory(userMsg);
-
-    const messages: ChatMessage[] = [
-        { role: 'system', content: buildSystemPrompt() },
-        ...conversationHistory,
-    ];
-
-    try {
-        const result = await routeChat(messages, {
-            temperature: options?.temperature ?? 0.7,
-            maxTokens: 512,
-        });
-
-        const assistantContent = result?.text || '';
-        addToHistory({ role: 'assistant', content: assistantContent });
-
-        if (result) {
-            console.log(`🧠[Chat] Response via ${result.backend} (${result.model}) in ${result.latencyMs} ms`);
-        }
-
-        return assistantContent;
-    } catch (error) {
-        if (error instanceof DOMException && error.name === 'TimeoutError') {
-            return '⏳ La respuesta del modelo tardó demasiado. Intenta con una pregunta más corta.';
-        }
-        throw error;
-    }
-}
-
-/**
- * Send a chat message and stream the response token-by-token.
- * NOTE: Streaming only works with Ollama directly (local provider).
- * For cloud providers, this falls back to non-streaming.
- */
-export async function* chatStream(
-    userMessage: string,
-    options?: { model?: string; temperature?: number }
-): AsyncGenerator<string, void, unknown> {
-    const model = options?.model || DEFAULT_MODEL;
-
-    const userMsg: OllamaChatMessage = { role: 'user', content: userMessage };
-    addToHistory(userMsg);
-
-    const messages: OllamaChatMessage[] = [
-        { role: 'system', content: buildSystemPrompt() },
-        ...conversationHistory,
-    ];
-
-    const res = await fetch(`${OLLAMA_BASE_URL}/api/chat`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            model,
-            messages,
-            stream: true,
-            options: {
-                temperature: options?.temperature ?? 0.7,
-                num_predict: 512,
-            },
-        }),
-    });
-
-    if (!res.ok || !res.body) {
-        throw new Error(`Ollama stream error: ${res.status}`);
-    }
-
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let fullContent = '';
-
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-
-            const chunk = decoder.decode(value, { stream: true });
-            const lines = chunk.split('\n').filter(Boolean);
-
-            for (const line of lines) {
-                try {
-                    const data = JSON.parse(line);
-                    if (data.message?.content) {
-                        fullContent += data.message.content;
-                        yield data.message.content;
-                    }
-                } catch {
-                    // Skip malformed chunks
-                }
-            }
-        }
-    } finally {
-        reader.releaseLock();
-    }
-
-    addToHistory({ role: 'assistant', content: fullContent });
-}

package/src/ai/services/PeerMesh.ts

@@ -1,373 +0,0 @@
-/**
- * PeerMesh — WebSocket-based P2P mesh for Decido OS instances
- *
- * Allows multiple Decido OS instances on the same network to form
- * a group and share AI results/context. Each peer maintains its
- * own provider keys (BYOK). Uses manual connection (IP:port) in
- * this first iteration; future versions will use mDNS auto-discovery.
- *
- * Protocol:
- *  - Host starts a WebSocket server on a port (default 9876)
- *  - Clients connect to the host's IP:port
- *  - Messages: join, leave, share-result, share-context, heartbeat
- *  - Max 8 peers per group
- */
-
-import { v4 as uuid } from 'uuid';
-
-// ─── Types ──────────────────────────────────────────────────
-
-export interface PeerInfo {
-  id: string;
-  name: string;
-  address: string;
-  joinedAt: number;
-  lastSeen: number;
-}
-
-export interface SharedResult {
-  peerId: string;
-  provider: string;
-  model: string;
-  prompt: string;
-  response: string;
-  timestamp: number;
-}
-
-interface PeerMessage {
-  type: 'join' | 'leave' | 'share-result' | 'share-context' | 'heartbeat' | 'peers-update';
-  peerId: string;
-  peerName: string;
-  payload?: unknown;
-}
-
-// ─── Constants ──────────────────────────────────────────────
-
-const DEFAULT_PORT = 9876;
-const HEARTBEAT_INTERVAL = 10_000; // 10s
-const PEER_TIMEOUT = 30_000; // 30s without heartbeat = dead
-const MAX_PEERS = 8;
-
-// ─── Event Callbacks ────────────────────────────────────────
-
-type PeersChangedCb = (peers: PeerInfo[]) => void;
-type HostingChangedCb = (isHosting: boolean) => void;
-type ConnectionChangedCb = (isConnected: boolean) => void;
-type SharedResultCb = (result: SharedResult) => void;
-
-// ─── PeerMesh Class ─────────────────────────────────────────
-
-class PeerMeshImpl {
-  private myId = uuid();
-  private myName = this._getHostname();
-  private peers = new Map<string, PeerInfo>();
-  private connections = new Map<string, WebSocket>();
-  private isHostingFlag = false;
-  private isConnectedFlag = false;
-  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
-  private cleanupTimer: ReturnType<typeof setInterval> | null = null;
-
-  // Event listeners
-  private peersListeners = new Set<PeersChangedCb>();
-  private hostingListeners = new Set<HostingChangedCb>();
-  private connectionListeners = new Set<ConnectionChangedCb>();
-  private resultListeners = new Set<SharedResultCb>();
-
-  // ── Host Mode ─────────────────────────────────────────
-
-  /**
-   * Start hosting a peer group.
-   * Note: In browser WebSocket server is not available. This method
-   * is a placeholder for Tauri (Rust-side server). In browser mode,
-   * we simulate by acting as a "relay" through a shared connection.
-   */
-  startHost(port = DEFAULT_PORT): void {
-    if (this.isHostingFlag) return;
-    this.isHostingFlag = true;
-    this._emitHosting(true);
-    this._startHeartbeat();
-    console.log(`🌐 [PeerMesh] Hosting on port ${port} (peer: ${this.myId.slice(0, 8)})`);
-    console.log(`🌐 [PeerMesh] ⚠️ Browser-mode: WebSocket server requires Tauri backend.`);
-    console.log(`🌐 [PeerMesh]    Use connectToPeer() from another instance to connect.`);
-  }
-
-  stopHost(): void {
-    if (!this.isHostingFlag) return;
-    this.isHostingFlag = false;
-    this._stopHeartbeat();
-    this._broadcast({ type: 'leave', peerId: this.myId, peerName: this.myName });
-    this._disconnectAll();
-    this._emitHosting(false);
-    console.log('🌐 [PeerMesh] Stopped hosting');
-  }
-
-  // ── Client Mode ───────────────────────────────────────
-
-  connectToPeer(address: string): void {
-    if (this.connections.size >= MAX_PEERS) {
-      console.warn(`🌐 [PeerMesh] Max peers (${MAX_PEERS}) reached`);
-      return;
-    }
-
-    const wsUrl = address.startsWith('ws') ? address : `ws://${address}`;
-    console.log(`🌐 [PeerMesh] Connecting to ${wsUrl}...`);
-
-    try {
-      const ws = new WebSocket(wsUrl);
-
-      ws.onopen = () => {
-        console.log(`🌐 [PeerMesh] ✅ Connected to ${address}`);
-        this.connections.set(address, ws);
-        this.isConnectedFlag = true;
-        this._emitConnection(true);
-
-        // Announce ourselves
-        this._send(ws, {
-          type: 'join',
-          peerId: this.myId,
-          peerName: this.myName,
-        });
-
-        this._startHeartbeat();
-      };
-
-      ws.onmessage = (event) => {
-        try {
-          const msg: PeerMessage = JSON.parse(event.data);
-          this._handleMessage(msg, address);
-        } catch { /* ignore malformed messages */ }
-      };
-
-      ws.onclose = () => {
-        console.log(`🌐 [PeerMesh] Disconnected from ${address}`);
-        this.connections.delete(address);
-        // Remove peer associated with this address
-        for (const [id, peer] of this.peers) {
-          if (peer.address === address) {
-            this.peers.delete(id);
-          }
-        }
-        this._emitPeers();
-        if (this.connections.size === 0) {
-          this.isConnectedFlag = false;
-          this._emitConnection(false);
-          this._stopHeartbeat();
-        }
-      };
-
-      ws.onerror = (err) => {
-        console.error(`🌐 [PeerMesh] Connection error to ${address}:`, err);
-      };
-    } catch (err) {
-      console.error(`🌐 [PeerMesh] Failed to connect:`, err);
-    }
-  }
-
-  disconnect(): void {
-    this._broadcast({ type: 'leave', peerId: this.myId, peerName: this.myName });
-    this._disconnectAll();
-  }
-
-  // ── Share Results ─────────────────────────────────────
-
-  shareResult(result: Omit<SharedResult, 'peerId' | 'timestamp'>): void {
-    const fullResult: SharedResult = {
-      ...result,
-      peerId: this.myId,
-      timestamp: Date.now(),
-    };
-
-    this._broadcast({
-      type: 'share-result',
-      peerId: this.myId,
-      peerName: this.myName,
-      payload: fullResult,
-    });
-
-    console.log(`🌐 [PeerMesh] Shared result to ${this.connections.size} peers`);
-  }
-
-  // ── Event Subscriptions ───────────────────────────────
-
-  onPeersChanged(cb: PeersChangedCb): () => void {
-    this.peersListeners.add(cb);
-    return () => { this.peersListeners.delete(cb); };
-  }
-
-  onHostingChanged(cb: HostingChangedCb): () => void {
-    this.hostingListeners.add(cb);
-    return () => { this.hostingListeners.delete(cb); };
-  }
-
-  onConnectionChanged(cb: ConnectionChangedCb): () => void {
-    this.connectionListeners.add(cb);
-    return () => { this.connectionListeners.delete(cb); };
-  }
-
-  onSharedResult(cb: SharedResultCb): () => void {
-    this.resultListeners.add(cb);
-    return () => { this.resultListeners.delete(cb); };
-  }
-
-  // ── Getters ───────────────────────────────────────────
-
-  getPeers(): PeerInfo[] {
-    return Array.from(this.peers.values());
-  }
-
-  getMyId(): string {
-    return this.myId;
-  }
-
-  getMyName(): string {
-    return this.myName;
-  }
-
-  // ── Message Handling ──────────────────────────────────
-
-  private _handleMessage(msg: PeerMessage, fromAddress: string): void {
-    switch (msg.type) {
-      case 'join':
-        this.peers.set(msg.peerId, {
-          id: msg.peerId,
-          name: msg.peerName,
-          address: fromAddress,
-          joinedAt: Date.now(),
-          lastSeen: Date.now(),
-        });
-        this._emitPeers();
-        console.log(`🌐 [PeerMesh] Peer joined: ${msg.peerName} (${msg.peerId.slice(0, 8)})`);
-        break;
-
-      case 'leave':
-        this.peers.delete(msg.peerId);
-        this._emitPeers();
-        console.log(`🌐 [PeerMesh] Peer left: ${msg.peerName}`);
-        break;
-
-      case 'heartbeat':
-        if (this.peers.has(msg.peerId)) {
-          this.peers.get(msg.peerId)!.lastSeen = Date.now();
-        }
-        break;
-
-      case 'share-result':
-        if (msg.payload) {
-          const result = msg.payload as SharedResult;
-          for (const cb of this.resultListeners) {
-            try { cb(result); } catch { /* ignore */ }
-          }
-        }
-        break;
-
-      case 'peers-update':
-        // Host sends updated peer list
-        if (Array.isArray(msg.payload)) {
-          for (const p of msg.payload as PeerInfo[]) {
-            if (p.id !== this.myId && !this.peers.has(p.id)) {
-              this.peers.set(p.id, p);
-            }
-          }
-          this._emitPeers();
-        }
-        break;
-    }
-  }
-
-  // ── Internal Helpers ──────────────────────────────────
-
-  private _send(ws: WebSocket, msg: PeerMessage): void {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify(msg));
-    }
-  }
-
-  private _broadcast(msg: PeerMessage): void {
-    for (const ws of this.connections.values()) {
-      this._send(ws, msg);
-    }
-  }
-
-  private _disconnectAll(): void {
-    for (const ws of this.connections.values()) {
-      try { ws.close(); } catch { /* ignore */ }
-    }
-    this.connections.clear();
-    this.peers.clear();
-    this.isConnectedFlag = false;
-    this._stopHeartbeat();
-    this._emitPeers();
-    this._emitConnection(false);
-  }
-
-  private _startHeartbeat(): void {
-    if (this.heartbeatTimer) return;
-
-    this.heartbeatTimer = setInterval(() => {
-      this._broadcast({
-        type: 'heartbeat',
-        peerId: this.myId,
-        peerName: this.myName,
-      });
-    }, HEARTBEAT_INTERVAL);
-
-    this.cleanupTimer = setInterval(() => {
-      const now = Date.now();
-      let changed = false;
-      for (const [id, peer] of this.peers) {
-        if (now - peer.lastSeen > PEER_TIMEOUT) {
-          this.peers.delete(id);
-          changed = true;
-          console.log(`🌐 [PeerMesh] Peer timed out: ${peer.name}`);
-        }
-      }
-      if (changed) this._emitPeers();
-    }, PEER_TIMEOUT);
-  }
-
-  private _stopHeartbeat(): void {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer);
-      this.cleanupTimer = null;
-    }
-  }
-
-  // ── Event Emitters ────────────────────────────────────
-
-  private _emitPeers(): void {
-    const list = this.getPeers();
-    for (const cb of this.peersListeners) {
-      try { cb(list); } catch { /* ignore */ }
-    }
-  }
-
-  private _emitHosting(hosting: boolean): void {
-    for (const cb of this.hostingListeners) {
-      try { cb(hosting); } catch { /* ignore */ }
-    }
-  }
-
-  private _emitConnection(connected: boolean): void {
-    for (const cb of this.connectionListeners) {
-      try { cb(connected); } catch { /* ignore */ }
-    }
-  }
-
-  // ── Hostname ──────────────────────────────────────────
-
-  private _getHostname(): string {
-    try {
-      return `user-${Math.random().toString(36).slice(2, 6)}`;
-    } catch {
-      return 'anonymous';
-    }
-  }
-}
-
-// ─── Singleton Export ───────────────────────────────────────
-
-export const peerMesh = new PeerMeshImpl();