@johpaz/hive 1.7.2 → 1.7.3

package/packages/core/src/agent/service.ts

@@ -1,266 +0,0 @@
-/**
- * AgentService — Wrapper del nuevo agent-loop nativo.
- * 
- * Reemplaza la clase Agent legacy.
- * Mantiene compatibilidad con server.ts pero usa el agent-loop nativo por debajo.
- * 
- * Responsabilidades:
- * - Cargar agente desde DB
- * - Cargar ética desde DB
- * - Obtener MCP Manager
- * - Hot reload (MCP, skills, ethics)
- * - Eventos (cron, etc.)
- */
-
-import { getDb } from "../storage/sqlite"
-import { logger } from "../utils/logger"
-import { buildSystemPromptWithProjects } from "./prompt-builder"
-import { getAgentLoop, rebuildAgentLoop } from "./agent-loop"
-import type { MCPClientManager } from "@johpaz/hive-mcp"
-import { resolveAgentId, resolveUserId } from "../storage/onboarding"
-import { getMCPManager as getSingletonMCPManager } from "../mcp/singleton"
-
-const log = logger.child("agent-service")
-
-// Event handler types
-type CronHandler = (sessionId: string, task: string, jobId?: string, context?: any) => Promise<void>
-
-export interface AgentServiceConfig {
-  agentId?: string
-  workspacePath?: string
-}
-
-export interface AgentDBRecord {
-  id: string
-  user_id: string
-  name: string
-  description: string | null
-  system_prompt: string | null
-  tone: string | null
-  role: string
-  status: string
-  enabled: number
-  provider_id: string
-  model_id: string
-  tools_json: string | null
-  skills_json: string | null
-  parent_id: string | null
-  max_iterations: number
-  headers_encrypted: string | null
-  headers_iv: string | null
-  created_at: number
-  updated_at: number
-}
-
-export class AgentService {
-  private agentId: string
-  private workspacePath: string
-  private mcpManager: MCPClientManager | null = null
-  private cronHandlers: CronHandler[] = []
-  private initialized: boolean = false
-
-  constructor(config?: AgentServiceConfig) {
-    // Resolve agentId from database if not provided
-    this.agentId = config?.agentId || resolveAgentId(null) || "main"
-    this.workspacePath = config?.workspacePath || ""
-  }
-
-  /**
-   * Inicializa el servicio del agente
-   * - Carga el MCP Manager
-   * - Configura el supervisor graph
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) {
-      log.debug("AgentService already initialized")
-      return
-    }
-
-    try {
-      // Obtener MCP Manager del agent loop
-      const agentLoop = getAgentLoop()
-      if (agentLoop) {
-        // MCP Manager se inicializa en el agent-loop
-        log.info("AgentService: MCP Manager available from agent-loop")
-      }
-
-      this.initialized = true
-      log.info(`AgentService initialized for agent=${this.agentId}`)
-    } catch (error) {
-      log.error(`Failed to initialize AgentService: ${(error as Error).message}`)
-      throw error
-    }
-  }
-
-  /**
-   * Obtiene el registro del agente desde la DB
-   */
-  async getAgent(agentId?: string): Promise<AgentDBRecord | null> {
-    const db = getDb()
-    const id = agentId || this.agentId
-    
-    const agent = db.query<any, [string]>(
-      "SELECT * FROM agents WHERE id = ? LIMIT 1"
-    ).get(id) as AgentDBRecord | undefined
-
-    return agent || null
-  }
-
-  /**
-   * Obtiene la ética desde la DB
-   */
-  async getEthics(): Promise<string> {
-    const db = getDb()
-    const ethics = db.query<any, []>(
-      "SELECT content FROM ethics WHERE active = 1 LIMIT 1"
-    ).get() as { content: string } | undefined
-
-    return ethics?.content || ""
-  }
-
-  /**
-   * Obtiene el MCP Manager
-   */
-  getMCPManager(): MCPClientManager | null {
-    const agentLoop = getAgentLoop()
-    if (agentLoop && (agentLoop as any).mcpManager) {
-      return (agentLoop as any).mcpManager as MCPClientManager
-    }
-    // Fallback to singleton
-    return getSingletonMCPManager()
-  }
-
-  /**
-   * Recarga la configuración del MCP
-   */
-  async reloadMCP(): Promise<void> {
-    log.info("Reloading MCP configuration...")
-    const mcp = this.getMCPManager()
-    if (mcp) {
-      await mcp.reconnectAll().catch(err => {
-        log.warn(`Failed to reconnect MCP: ${(err as Error).message}`)
-      })
-    }
-    log.info("MCP reloaded")
-  }
-
-  /**
-   * Recarga los skills desde la DB
-   */
-  async reloadSkills(): Promise<void> {
-    log.info("Reloading skills...")
-    const { syncSkillsToFTS } = await import("./context-compiler")
-    syncSkillsToFTS()
-    log.info("Skills reloaded")
-  }
-
-  /**
-   * Recarga la ética desde la DB
-   */
-  async reloadEthics(): Promise<void> {
-    log.info("Reloading ethics...")
-    // La ética se carga automáticamente en buildSystemPrompt()
-    // No hay acción necesaria aquí
-    log.info("Ethics reloaded (will be picked up on next agent call)")
-  }
-
-  /**
-   * Recarga el soul (system prompt del agente)
-   */
-  async reloadSoul(): Promise<void> {
-    log.info("Reloading soul...")
-    // El soul se carga automáticamente desde DB en buildSystemPrompt()
-    log.info("Soul reloaded (will be picked up on next agent call)")
-  }
-
-  /**
-   * Recarga la configuración del usuario
-   */
-  async reloadUser(): Promise<void> {
-    log.info("Reloading user configuration...")
-    // La configuración del usuario se carga desde DB en buildSystemPrompt()
-    log.info("User configuration reloaded (will be picked up on next agent call)")
-  }
-
-  /**
-   * Actualiza la configuración del agente
-   */
-  async updateConfig(config: any): Promise<void> {
-    log.info("Updating agent configuration...")
-    // La configuración ahora se carga desde DB dinámicamente
-    // No hay acción necesaria aquí
-    log.info("Configuration updated (will be picked up from DB)")
-  }
-
-  /**
-   * Recarga el agente (hot reload)
-   */
-  async reload(): Promise<void> {
-    log.info("Reloading agent...")
-    await this.reloadMCP()
-    await this.reloadSkills()
-    await this.reloadEthics()
-    log.info("Agent reloaded")
-  }
-
-  /**
-   * Registra un handler para eventos cron
-   */
-  on(event: 'cron', handler: CronHandler): void {
-    if (event === 'cron') {
-      this.cronHandlers.push(handler)
-      log.debug(`Registered cron handler, total=${this.cronHandlers.length}`)
-    }
-  }
-
-  /**
-   * Emite un evento cron
-   */
-  emit(event: 'cron', sessionId: string, task: string, jobId?: string, context?: any): void {
-    if (event === 'cron') {
-      log.debug(`Emitting cron event: task=${task}, sessionId=${sessionId}, jobId=${jobId}`)
-      for (const handler of this.cronHandlers) {
-        handler(sessionId, task, jobId, context).catch(err => {
-          log.error(`Cron handler error: ${(err as Error).message}`)
-        })
-      }
-    }
-  }
-
-  /**
-   * Obtiene el system prompt para un agente
-   */
-  async getSystemPrompt(agentId?: string, userId?: string): Promise<string> {
-    const id = agentId || this.agentId
-    const uid = userId || resolveUserId({}) || "default"
-    return buildSystemPromptWithProjects({ agentId: id, userId: uid })
-  }
-
-  /**
-   * Ejecuta un agente con un mensaje
-   */
-  async runAgent(message: string, threadId: string, userId?: string): Promise<string> {
-    const { runAgentIsolated } = await import("./agent-loop")
-    const result = await runAgentIsolated({
-      agentId: this.agentId,
-      taskDescription: message,
-      threadId,
-    })
-    return result
-  }
-}
-
-// Singleton para compatibilidad
-let _agentService: AgentService | null = null
-
-export function getAgentService(): AgentService {
-  if (!_agentService) {
-    _agentService = new AgentService()
-  }
-  return _agentService
-}
-
-export function createAgentService(config?: AgentServiceConfig): AgentService {
-  _agentService = new AgentService(config)
-  return _agentService
-}

package/packages/core/src/agent/skill-selector.ts

@@ -1,413 +0,0 @@
-/**
- * FTS5-based Dynamic Skill Selector Module
- * 
- * Context Compiler Level 4 - Intelligent Skill Selection
- * 
- * This module uses SQLite FTS5 bm25() scoring to select the most relevant
- * skills (0-5) based on the user message, similar to tool selection.
- * 
- * DESIGN DECISIONS:
- * 
- * 1. Reads from skills table in database (not hardcoded catalog)
- * 2. Maximum 5 skills per turn for balanced context injection
- * 3. Relevance threshold for conversational messages
- * 4. Uses skill descriptions for FTS5 matching
- * 5. Returns skill content for injection into system prompt
- */
-
-import { getDb } from "../storage/sqlite"
-import { logger } from "../utils/logger"
-
-const log = logger.child("skill-selector")
-
-// ─── Types ───────────────────────────────────────────────────────────────────────
-
-export interface SkillDescriptor {
-    id: string
-    name: string
-    category: string
-    tools: string
-    triggers: string
-    body: string
-    version: number
-    active: number
-}
-
-export interface SelectedSkill {
-    id: string
-    name: string
-    score: number
-    category: string
-    body: string
-}
-
-export interface SkillSelectorResult {
-    skills: SkillDescriptor[]
-    selected: SelectedSkill[]
-    reasoning: string
-    timingMs: number
-}
-
-// ─── Configuration ─────────────────────────────────────────────────────────
-
-/** Maximum skills to return per message */
-const MAX_SKILLS_PER_TURN = 5
-
-/** Minimum bm25 score threshold. Below this = conversational, no skills needed. */
-const MIN_RELEVANCE_THRESHOLD = -10
-
-/** Stopwords to filter out before FTS5 query construction */
-const STOPWORDS = new Set([
-    "que", "con", "para", "por", "una", "uno", "los", "las", "del",
-    "como", "esta", "esto", "ese", "eso", "the", "and", "for",
-    "with", "this", "that", "have", "will", "also", "de", "en",
-    "el", "la", "se", "su", "sus", "al", "es", "son", "pero",
-    "más", "mas", "ya", "yo", "tu", "te", "ti", "mi", "me",
-    "hola", "hi", "hello", "hey", "gracias", "thank", "please",
-    "ok", "okay", "yes", "si", "no", "bien", "good", "great",
-])
-
-/** Conversational patterns that should return empty skill list */
-const CONVERSATIONAL_PATTERNS = [
-    /^(hola|hi|hello|hey|buenos? días?|buenas? noches?|qué tal|howdy)/i,
-    /^(gracias|thank you|thanks|muchas gracias|muchas thanks)/i,
-    /^(cómo estás?|how are you?|qué流水|you doing|qué cuentas)/i,
-    /^(sí|yes|ok|okay|de acuerdo|perfecto|claro|por supuesto)/i,
-    /^(adiós|bye|nos vemos|see you|later|chau)/i,
-    /^(entiendo|understand|i see|ya veo|got it)/i,
-    /^(bien|good|great|excelente|awesome|perfect)/i,
-    /^(?:\?|¿)$/,  // Just a question mark
-]
-
-// ─── Helper Functions ───────────────────────────────────────────────────────
-
-/**
- * Check if message is purely conversational (no skills needed)
- */
-function isConversational(message: string): boolean {
-    const trimmed = message.trim()
-
-    // Empty or very short messages
-    if (trimmed.length < 2) return true
-
-    // Check conversational patterns
-    for (const pattern of CONVERSATIONAL_PATTERNS) {
-        if (pattern.test(trimmed)) {
-            log.debug(`[skill-selector] Message matched conversational pattern: ${pattern}`)
-            return true
-        }
-    }
-
-    // Check if all words are stopwords (likely conversational)
-    const words = trimmed.toLowerCase().split(/\s+/)
-    const meaningfulWords = words.filter(w => w.length > 2 && !STOPWORDS.has(w))
-    if (meaningfulWords.length === 0) {
-        log.debug(`[skill-selector] All words are stopwords - conversational`)
-        return true
-    }
-
-    return false
-}
-
-/**
- * Build FTS5 query from user message
- */
-function buildFTSQuery(message: string): string {
-    const words = message
-        .toLowerCase()
-        .replace(/[^\p{L}\p{N}\s]/gu, " ")
-        .split(/\s+/)
-        .filter((w) => w.length > 2 && !STOPWORDS.has(w))
-        .slice(0, 8)
-
-    if (words.length === 0) return ""
-
-    return words.join(" OR ")
-}
-
-/**
- * Check if message matches explicit triggers from a skill
- */
-function matchTriggers(message: string, triggersJson: string | null): boolean {
-    if (!triggersJson) return false
-
-    try {
-        // Triggers are stored as comma-separated string in DB (e.g., "trigger1,trigger2")
-        const triggers: string[] = triggersJson.split(",").map(t => t.trim()).filter(t => t.length > 0)
-        if (triggers.length === 0) return false
-
-        const lowerMessage = message.toLowerCase()
-        return triggers.some(trigger =>
-            lowerMessage.includes(trigger.toLowerCase())
-        )
-    } catch (err) {
-        log.warn(`[skill-selector] Failed to parse triggers: ${(err as Error).message}`)
-        return false
-    }
-}
-
-// ─── Main Selection Function ─────────────────────────────────────────────────
-
-/**
- * Select skills for a given user message using hybrid matching:
- * 1. First check explicit triggers (high confidence match)
- * 2. Fallback to FTS5 bm25() scoring for semantic matching
- *
- * @param userMessage - The raw user message
- * @returns Array of 0-5 selected skills with scores
- *
- * ALGORITHM:
- * 1. If conversational → return []
- * 2. Check explicit triggers from all enabled skills
- * 3. If trigger match found → return matching skill immediately
- * 4. Build FTS5 query from message keywords
- * 5. Query skills_fts with bm25() scoring
- * 6. Filter results below MIN_RELEVANCE_THRESHOLD
- * 7. Return top MAX_SKILLS_PER_TURN results
- */
-export function selectSkills(userMessage: string): SkillDescriptor[] {
-    const startTime = performance.now()
-
-    log.debug(`[skill-selector] Processing user message: "${userMessage.substring(0, 100)}"`)
-
-    // Step 1: Check if conversational
-    if (isConversational(userMessage)) {
-        log.debug(`[skill-selector] Conversational message, returning empty array`)
-        return []
-    }
-
-    // Step 2: Check explicit triggers first (high priority)
-    const db = getDb()
-    const allSkills = db.query(`
-        SELECT id, name, category, tools, triggers, body, version, active
-        FROM skills
-        WHERE active = 1
-    `).all() as SkillDescriptor[]
-
-    // Check trigger match - if found, return immediately with high confidence
-    for (const skill of allSkills) {
-        if (skill.triggers && matchTriggers(userMessage, skill.triggers)) {
-            log.info(`[skill-selector] Trigger match found: ${skill.name}`)
-            return [skill]
-        }
-    }
-
-    // Step 3: Build FTS5 query for semantic matching
-    const ftsQuery = buildFTSQuery(userMessage)
-    if (!ftsQuery) {
-        log.debug(`[skill-selector] No valid FTS query terms, returning empty array`)
-        return []
-    }
-
-    log.debug(`[skill-selector] FTS query: "${ftsQuery}"`)
-
-    // Step 4: Execute FTS5 query with bm25 scoring
-    // Use bm25() for relevance scoring (FTS5 table is populated in gateway/initializer.ts)
-    const ftsResults = db.query(`
-        SELECT id, bm25(skills_fts) as bm25_score
-        FROM skills_fts
-        WHERE skills_fts MATCH ?
-        ORDER BY bm25_score ASC
-        LIMIT 20
-    `).all(ftsQuery) as { id: string; bm25_score: number }[]
-
-    if (ftsResults.length === 0) {
-        log.debug(`[skill-selector] No FTS matches, returning empty array`)
-        return []
-    }
-
-    log.debug(`[skill-selector] Raw FTS results:`, ftsResults.slice(0, 5))
-
-    // Step 5: Apply relevance threshold filter
-    const relevantResults = ftsResults.filter(r => r.bm25_score >= MIN_RELEVANCE_THRESHOLD)
-
-    if (relevantResults.length === 0) {
-        log.debug(`[skill-selector] All results below threshold ${MIN_RELEVANCE_THRESHOLD}, returning empty`)
-        return []
-    }
-
-    // Step 6: Fetch full skill details from database
-    const skillIds = relevantResults.map(r => r.id)
-
-    let dbSkills: SkillDescriptor[] = []
-    try {
-        const db = getDb()
-        dbSkills = db.query(`
-            SELECT id, name, category, tools, triggers, body, version, active
-            FROM skills
-            WHERE id IN (${skillIds.map(() => '?').join(',')})
-            AND active = 1
-        `).all(...skillIds) as SkillDescriptor[]
-    } catch (err) {
-        log.warn(`[skill-selector] Failed to fetch skills from DB:`, err)
-        return []
-    }
-
-    // Map scores to skills
-    const skillMap = new Map(dbSkills.map(s => [s.id, s]))
-    const scoredSkills: SelectedSkill[] = []
-
-    for (const result of relevantResults) {
-        const skill = skillMap.get(result.id)
-        if (skill) {
-            scoredSkills.push({
-                id: skill.id,
-                name: skill.name,
-                score: result.bm25_score,
-                category: skill.category,
-                body: skill.body,
-            })
-        }
-    }
-
-    // Step 7: Take top N skills
-    const topSkills = scoredSkills.slice(0, MAX_SKILLS_PER_TURN)
-
-    // Step 8: Return as SkillDescriptor array
-    const result = topSkills.map(t => skillMap.get(t.id)!).filter(Boolean)
-
-    const timing = performance.now() - startTime
-
-    if (result.length > 0) {
-        log.info(`[skill-selector] Selected ${result.length} skills in ${timing.toFixed(2)}ms:`,
-            result.map(s => ({ name: s.name, category: s.category })))
-    } else {
-        log.debug(`[skill-selector] No skills selected, returning empty array in ${timing.toFixed(2)}ms`)
-    }
-
-    return result
-}
-
-// ─── Sync Skills to FTS5 ───────────────────────────────────────────────────
-
-/**
- * Sync all enabled skills from database to FTS5
- * Should be called on initialization from gateway/initializer.ts
- * The skills_fts table is created by seed.ts
- */
-export async function syncSkillsToFTS(): Promise<void> {
-    const db = getDb()
-
-    try {
-        // Step 1: Get all enabled skills from database (simplified schema)
-        const dbSkills = db.query(`
-            SELECT id, name, category, tools, triggers, body
-            FROM skills
-            WHERE active = 1
-        `).all() as Array<{
-            id: string
-            name: string
-            category: string
-            tools: string
-            triggers: string
-            body: string
-        }>
-
-        if (dbSkills.length === 0) {
-            log.debug(`[skill-selector] No skills found in DB to sync`)
-        }
-
-        // Step 2: Atomic transaction for FTS5 sync
-        const syncTransaction = db.transaction(() => {
-            // Verify table exists
-            const tableCheck = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='skills_fts'").get()
-            if (!tableCheck) {
-                throw new Error("skills_fts table does not exist!")
-            }
-
-            // A: Clear existing data
-            db.run("DELETE FROM skills_fts")
-
-            // B: Prepare insertion (simplified schema matching new skills table)
-            const insert = db.prepare(`
-                INSERT INTO skills_fts(id, name, category, tools, triggers, body)
-                VALUES (?, ?, ?, ?, ?, ?)
-            `)
-
-            // C: Re-populate
-            for (const skill of dbSkills) {
-                insert.run(
-                    skill.id,
-                    skill.name,
-                    skill.category,
-                    skill.tools,
-                    skill.triggers,
-                    skill.body
-                )
-            }
-        })
-
-        // Execute transaction
-        syncTransaction()
-
-        log.info(`[skill-selector] Atomic sync complete: ${dbSkills.length} skills indexed in FTS5`)
-
-    } catch (err) {
-        log.error(`[skill-selector] Transactional sync failed:`, err)
-        throw err // Re-throw to inform initializer
-    }
-}
-// ─── Initialization ───────────────────────────────────────────────────────
-
-/**
- * Initialize the skill selector
- * DEPRECATED: syncSkillsToFTS() is now called from gateway/initializer.ts
- * This function is kept for backward compatibility but is no longer needed
- */
-export function initializeSkillSelector(): void {
-    log.info(`[skill-selector] Initializing skill selector (deprecated - sync is done in gateway/initializer.ts)`)
-    // syncSkillsToFTS() - No longer needed here, done in gateway/initializer.ts
-}
-
-// ─── Debug/Test Helpers ─────────────────────────────────────────────────────
-
-/**
- * Get all enabled skills from database (for debugging/testing)
- */
-export function getAllSkillsFromDB(): SkillDescriptor[] {
-    try {
-        const db = getDb()
-        return db.query(`
-            SELECT id, name, category, tools, triggers, body, version, active
-            FROM skills
-            WHERE active = 1
-        `).all() as SkillDescriptor[]
-    } catch (err) {
-        log.error(`[skill-selector] Failed to fetch skills:`, err)
-        return []
-    }
-}
-
-/**
- * Get skill by name
- */
-export function getSkillByName(name: string): SkillDescriptor | undefined {
-    try {
-        const db = getDb()
-        return db.query(`
-            SELECT id, name, category, tools, triggers, body, version, active
-            FROM skills
-            WHERE name = ? AND active = 1
-        `).get(name) as SkillDescriptor | undefined
-    } catch (err) {
-        log.error(`[skill-selector] Failed to fetch skill by name:`, err)
-        return undefined
-    }
-}
-
-/**
- * Get skills by category
- */
-export function getSkillsByCategory(category: string): SkillDescriptor[] {
-    try {
-        const db = getDb()
-        return db.query(`
-            SELECT id, name, category, tools, triggers, body, version, active
-            FROM skills
-            WHERE category = ? AND active = 1
-        `).all(category) as SkillDescriptor[]
-    } catch (err) {
-        log.error(`[skill-selector] Failed to fetch skills by category:`, err)
-        return []
-    }
-}