@johpaz/hive 1.7.2 → 1.7.3

package/packages/core/src/agent/prompt-builder.ts

@@ -1,167 +0,0 @@
-/**
- * Prompt Builder — Construye el system prompt con la jerarquía constitucional.
- *
- * Orden de ensamblaje:
- * 1. ÉTICA (capa constitucional, siempre completa, inmutable)
- * 2. IDENTIDAD DEL AGENTE (de la tabla agents)
- * 3. HIVE ECOSYSTEM (system prompt directo para el coordinador)
- * 4. IDENTIDAD DEL USUARIO (de la tabla users)
- *
- * El Context Compiler agrega después:
- * - Playbook rules (ACE)
- * - Scratchpad notes
- * - Skills activos
- */
-
-import { getDb } from "../storage/sqlite"
-import { logger } from "../utils/logger"
-import { formatContext } from "../utils/toon"
-import { resolveUserId } from "../storage/onboarding"
-
-const log = logger.child("prompt-builder")
-
-export interface BuildSystemPromptOpts {
-  agentId: string
-  userId: string
-}
-
-/**
- * Construye el system prompt completo para un agente.
- *
- * Jerarquía:
- * 1. Ética (siempre completa, no se filtra, no se comprime)
- * 2. Identidad del agente (role, description, system_prompt)
- * 3. Hive Ecosystem (ya incluido en agents.system_prompt desde onboarding.ts)
- * 4. Identidad del usuario (nombre, preferencias, contexto)
- */
-export async function buildSystemPrompt(opts: BuildSystemPromptOpts): Promise<string> {
-  const db = getDb()
-  const { agentId, userId } = opts
-
-  // ──────────────────────────────────────────────────────────────────────────
-  // 1. ÉTICA — Capa constitucional (siempre completa)
-  // ──────────────────────────────────────────────────────────────────────────
-  const ethicsRules = db.query<any, []>(`
-    SELECT name, content, description
-    FROM ethics
-    WHERE enabled = 1 AND active = 1
-    ORDER BY is_default DESC, id ASC
-  `).all()
-
-  let ethicsSection = ""
-  if (ethicsRules.length > 0) {
-    const ethicsContent = ethicsRules.map((rule: any) => {
-      return `## ${rule.name}\n${rule.content}`
-    }).join("\n\n")
-
-    ethicsSection = `# ÉTICA Y REGLAS CONSTITUCIONALES\n\n${ethicsContent}\n\n`
-    log.info(`[prompt-builder] Loaded ${ethicsRules.length} ethics rules`)
-  } else {
-    // Ética por defecto si no hay reglas configuradas
-    ethicsSection = `# ÉTICA Y REGLAS CONSTITUCIONALES\n\n` +
-      `- Sé útil, inofensivo y honesto\n` +
-      `- No generes contenido dañino, ilegal o peligroso\n` +
-      `- Respeta la privacidad y seguridad del usuario\n` +
-      `- Si no sabes algo, admítelo\n\n`
-  }
-
-  // ──────────────────────────────────────────────────────────────────────────
-  // 2. IDENTIDAD DEL AGENTE
-  // ──────────────────────────────────────────────────────────────────────────
-  const agent = db.query<any, [string]>(`
-    SELECT id, name, role, description, system_prompt, tone, max_iterations, workspace
-    FROM agents
-    WHERE id = ?
-  `).get(agentId)
-
-  if (!agent) {
-    throw new Error(`Agent not found: ${agentId}`)
-  }
-
-  let agentSection = `# IDENTIDAD DEL AGENTE\n\n`
-  agentSection += `**Nombre**: ${agent.name}\n`
-  agentSection += `**Rol**: ${agent.role}\n`
-
-  if (agent.description) {
-    agentSection += `**Descripción**: ${agent.description}\n`
-  }
-
-  if (agent.tone) {
-    agentSection += `**Tono**: ${agent.tone}\n`
-  }
-
-  agentSection += `**Iteraciones máximas**: ${agent.max_iterations}\n\n`
-
-  // Workspace configuration
-  const workspacePath = agent.workspace || null
-  if (workspacePath) {
-    agentSection += `# WORKSPACE — ESPACIO DE TRABAJO EXCLUSIVO\n\n`
-    agentSection += `**Tu directorio de trabajo es**: \`${workspacePath}\`\n\n`
-    agentSection += `## REGLAS OBLIGATORIAS (no negociables)\n\n`
-    agentSection += `1. **TODAS** tus operaciones de archivos y comandos ocurren DENTRO de \`${workspacePath}\`. Sin excepciones.\n`
-    agentSection += `2. Cuando el sistema te pida listar archivos, explorar, leer o escribir — hazlo SIEMPRE dentro de \`${workspacePath}\`.\n`
-    agentSection += `3. Nunca uses \`ls\`, \`find\`, \`cat\` u otras herramientas apuntando a directorios del sistema (\`/\`, \`~\`, \`/home\`, \`/etc\`, etc.).\n`
-    agentSection += `4. Cuando uses \`cli_exec\`, el directorio de trabajo ya es \`${workspacePath}\` por defecto — NO necesitas especificar \`cwd\`.\n`
-    agentSection += `5. Para rutas relativas, son relativas a \`${workspacePath}\` — no al directorio del proceso.\n`
-    agentSection += `6. Si el usuario pide explorar "el proyecto" o "los archivos", asume que se refiere a \`${workspacePath}\`.\n`
-    agentSection += `7. Las tools de filesystem (\`fs_read\`, \`fs_write\`, \`fs_list\`, etc.) ya tienen tu workspace configurado — úsalas directamente con rutas relativas.\n\n`
-    agentSection += `> IMPORTANTE: Cualquier intento de acceder fuera de \`${workspacePath}\` será bloqueado automáticamente por el sistema.\n\n`
-  }
-
-  // System prompt específico del agente (su "personalidad" especializada)
-  if (agent.system_prompt) {
-    agentSection += `## System Prompt\n\n${agent.system_prompt}\n\n`
-  }
-
-
-  // ──────────────────────────────────────────────────────────────────────────
-  // 3. IDENTIDAD DEL USUARIO
-  // ──────────────────────────────────────────────────────────────────────────
-  const user = db.query<any, [string]>(`
-    SELECT id, name, language,  timezone, occupation, notes
-    FROM users
-    WHERE id = ?
-  `).get(userId)
-
-  let userSection = `# IDENTIDAD DEL USUARIO\n\n`
-
-  if (user) {
-    const userData: Record<string, string | null> = {}
-
-    if (user.name) userData.Nombre = user.name
-    if (user.language) userData.Idioma = user.language
-    if (user.timezone) userData.ZonaHoraria = user.timezone
-    if (user.occupation) userData.Ocupación = user.occupation
-    if (user.notes) userData.Notes = user.notes
-
-    // Usar TOON para comprimir datos del usuario
-    if (Object.keys(userData).length > 0) {
-      userSection += formatContext(userData) + "\n\n"
-    } else {
-      userSection += `Usuario ID: ${userId}\n\n`
-    }
-  } else {
-    userSection += `Usuario ID: ${userId}\n\n`
-  }
-
-  // ──────────────────────────────────────────────────────────────────────────
-  // Ensamblar secciones en orden
-  // ──────────────────────────────────────────────────────────────────────────
-  const systemPrompt = `${ethicsSection}${agentSection}${userSection}`.trim()
-
-  log.info(`[prompt-builder] Built system prompt for agent=${agent.name} role=${agent.role}`)
-
-  return systemPrompt
-}
-
-/**
- * Versión simplificada para cuando solo se necesita el agentId
- * (usa userId por defecto de env o threadId)
- */
-export async function buildSystemPromptWithProjects(opts: {
-  agentId: string
-  userId?: string
-}): Promise<string> {
-  const userId = opts.userId || resolveUserId({}) || "default"
-  return buildSystemPrompt({ agentId: opts.agentId, userId })
-}

package/packages/core/src/agent/providers/index.ts

@@ -1,186 +0,0 @@
-/**
- * AgentRunner — thin wrapper over the native AgentLoop.
- *
- * Keeps the same public API (generate()) so server.ts doesn't need changes.
- * Internally uses agent-loop.ts instead of LangGraph.
- */
-
-import type { Config } from "../../config/loader.ts"
-import { logger } from "../../utils/logger.ts"
-import { getDb } from "../../storage/sqlite.ts"
-import { getAgentLoop } from "../agent-loop"
-import { resolveUserId, resolveAgentId } from "../../storage/onboarding"
-
-export type Provider = "openai" | "anthropic" | "gemini" | "mistral" | "kimi" | "ollama" | "openrouter" | "deepseek"
-
-export interface StepEvent {
-  type: "text" | "plan" | "tool_call" | "tool_result"
-  message: string
-  toolName?: string
-  isError?: boolean
-}
-
-export interface ModelOptions {
-  provider?: Provider
-  model?: string
-  maxTokens?: number
-  temperature?: number
-  system?: string
-  messages: Array<{ role: string; content: string }>
-  tools?: Record<string, any>
-  maxSteps?: number
-  onToken?: (token: string) => void
-  onStep?: (step: StepEvent) => Promise<void>
-  threadId?: string
-  userId?: string
-  channel?: string
-  rawUserMessage?: string
-}
-
-export interface ModelResponse {
-  content: string
-  toolCalls?: Array<{
-    id: string
-    name: string
-    args: Record<string, unknown>
-  }>
-  usage?: {
-    promptTokens: number
-    completionTokens: number
-    totalTokens: number
-  }
-  finishReason?: string
-}
-
-export class AgentRunner {
-  private config: Config
-
-  constructor(config: Config) {
-    this.config = config
-  }
-
-  async generate(options: ModelOptions): Promise<ModelResponse> {
-    const db = getDb()
-    // Resolve agentId from database (coordinator or first enabled)
-    const agentId = resolveAgentId(null) || "main"
-
-    // Resolve userId from database
-    const userId = options.userId || resolveUserId({})
-    if (!userId) {
-      throw new Error("No userId provided. Please complete onboarding first.")
-    }
-    const threadId = options.threadId || userId
-
-    const agentLoop = getAgentLoop()
-    if (!agentLoop) {
-      throw new Error("AgentLoop not initialized")
-    }
-
-    let lastAgentContent = ""
-    let accumulatedAgentContent = ""  // Accumulate content from all agent chunks
-    let toolCalls: ModelResponse["toolCalls"] = []
-
-    try {
-      const stream = agentLoop.stream(
-        { messages: options.messages },
-        {
-          configurable: {
-            thread_id: threadId,
-            agent_id: agentId,
-            user_id: userId,
-            // system_prompt intentionally omitted — context-compiler builds it
-            channel: options.channel,
-            raw_user_message: options.rawUserMessage,
-          },
-        }
-      )
-
-      let chunkCount = 0
-      for await (const chunk of stream) {
-        chunkCount++
-
-        if (chunk.agent?.messages) {
-          const lastMsg = chunk.agent.messages[chunk.agent.messages.length - 1]
-          const hasToolCalls = (lastMsg as any)?.tool_calls?.length > 0
-          const contentLen = lastMsg?.content?.length ?? 0
-          const contentType = typeof lastMsg?.content
-          logger.info(
-            `[STREAM] chunk#${chunkCount} agent: contentLen=${contentLen} hasToolCalls=${hasToolCalls} contentType=${contentType}`
-          )
-
-          if (lastMsg?.content) {
-            const content = typeof lastMsg.content === "string" ? lastMsg.content : ""
-            lastAgentContent = content
-            // Accumulate non-empty content that's not just whitespace
-            if (content && content.trim().length > 0) {
-              accumulatedAgentContent += (accumulatedAgentContent ? "\n" : "") + content
-              logger.debug(`[STREAM] Accumulated content: total length=${accumulatedAgentContent.length}`)
-            } else {
-              logger.debug(`[STREAM] Content empty or whitespace only, skipping accumulation`)
-            }
-            if (options.onToken) options.onToken(content)
-          } else {
-            logger.debug(`[STREAM] No content in chunk, lastMsg.content is falsy`)
-          }
-
-          if (hasToolCalls) {
-            toolCalls = (lastMsg as any).tool_calls.map((tc: any) => ({
-              id: tc.id || tc.function?.name,
-              name: tc.function?.name || tc.name,
-              args: tc.function?.arguments
-                ? (typeof tc.function.arguments === "string"
-                    ? JSON.parse(tc.function.arguments)
-                    : tc.function.arguments)
-                : {},
-            }))
-
-            const narration = lastMsg?.content || ""
-            if (options.onStep && narration) {
-              await options.onStep({ type: "text", message: narration })
-            }
-            if (options.onStep) {
-              for (const tc of toolCalls) {
-                await options.onStep({
-                  type: "tool_call",
-                  toolName: tc.name,
-                  message: `Calling tool: \`${tc.name}\``,
-                })
-              }
-            }
-          }
-        }
-
-        if (chunk.tools?.messages) {
-          const lastMsg = chunk.tools.messages[chunk.tools.messages.length - 1]
-          if (lastMsg?.content && options.onStep) {
-            await options.onStep({
-              type: "tool_result",
-              message: typeof lastMsg.content === "string" ? lastMsg.content : "",
-            })
-          }
-        }
-      }
-
-      logger.debug(`[STREAM] done. totalChunks=${chunkCount} lastAgentContent length=${lastAgentContent.length}, accumulated length=${accumulatedAgentContent.length}`)
-
-      // Use accumulated content if lastAgentContent is empty (handles case where final chunk has no text)
-      const finalContent = lastAgentContent || accumulatedAgentContent
-      
-      logger.info(`[STREAM] Returning response: finalContent length=${finalContent.length}, lastAgentContent length=${lastAgentContent.length}, accumulated length=${accumulatedAgentContent.length}`)
-
-      return {
-        content: finalContent,
-        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-        usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-        finishReason: "stop",
-      }
-    } catch (error) {
-      logger.error("AgentRunner error:", error)
-      throw error
-    }
-  }
-}
-
-export function createAgentRunner(config: Config): AgentRunner {
-  return new AgentRunner(config)
-}

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

@@ -1 +0,0 @@
-export * from "./providers/index.ts";

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

@@ -1,200 +0,0 @@
-/**
- * ACE Reflector — analyzes recent traces and produces insights.
- *
- * Runs in the background (never blocks the main agent loop).
- * Triggered by the tracer after N new traces.
- *
- * Output → `reflections` table → picked up by Curator.
- */
-
-import { logger } from "../utils/logger"
-
-const log = logger.child("reflector")
-
-const MAX_TRACES_TO_ANALYZE = 30
-const MIN_TRACES_TO_RUN = 10
-
-/** Main entry point — called from tracer.ts */
-export async function runReflector(): Promise<void> {
-  try {
-    const { getDb } = await import("../storage/sqlite")
-    const db = getDb()
-
-    log.info(`[reflector] Starting reflection cycle...`)
-
-    // Fetch traces not yet covered by any reflection
-    log.debug(`[reflector] Querying last reflection ID...`)
-    const lastReflectionId = (db.query<any, []>(
-      "SELECT MAX(id) as mid FROM reflections"
-    ).get() as any)?.mid ?? 0
-    log.debug(`[reflector] Last reflection ID: ${lastReflectionId}`)
-
-    // Get last processed trace ID from reflections
-    log.debug(`[reflector] Querying last processed trace ID with json_each...`)
-    let lastProcessedTrace = 0
-    try {
-      const result = (db.query<any, []>(
-        `SELECT MAX(CAST(json_each.value AS INTEGER)) as max_id
-         FROM reflections, json_each(reflections.trace_ids)
-         WHERE reflections.id = (SELECT MAX(id) FROM reflections)`
-      ).get() as any)?.max_id ?? 0
-      lastProcessedTrace = result
-      log.debug(`[reflector] Last processed trace ID: ${lastProcessedTrace}`)
-    } catch (jsonErr) {
-      log.error(`[reflector] json_each query failed:`, jsonErr)
-      log.error(`[reflector] Full error details:`, {
-        message: (jsonErr as Error).message,
-        stack: (jsonErr as Error).stack,
-        errno: (jsonErr as any).errno,
-        byteOffset: (jsonErr as any).byteOffset,
-      })
-      throw jsonErr // Re-throw to see full stack trace in main catch
-    }
-
-    log.debug(`[reflector] Fetching traces from DB, lastProcessedTrace=${lastProcessedTrace}, limit=${MAX_TRACES_TO_ANALYZE}`)
-    const traces = db.query<any, [number, number]>(`
-      SELECT id, agent_id, agent_name, tool_used, input_summary,
-             output_summary, success, error_message, duration_ms, tokens_used, created_at
-      FROM traces
-      WHERE id > ?
-      ORDER BY id ASC
-      LIMIT ?
-    `).all(lastProcessedTrace, MAX_TRACES_TO_ANALYZE)
-
-    log.debug(`[reflector] Fetched ${traces.length} traces from DB`)
-
-    if (traces.length < MIN_TRACES_TO_RUN) {
-      log.debug(`[reflector] Not enough traces (${traces.length}/${MIN_TRACES_TO_RUN}), skipping`)
-      return
-    }
-
-    log.info(`[reflector] Analyzing ${traces.length} traces...`)
-
-    const insights = analyzeTracesLocally(traces)
-
-    if (insights.length === 0) {
-      log.debug("[reflector] No insights generated")
-      return
-    }
-
-    const traceIds = JSON.stringify(traces.map((t: any) => t.id))
-
-    for (const insight of insights) {
-      db.query(`
-        INSERT INTO reflections (trace_ids, insight_type, description, affected_tools, affected_agents, confidence)
-        VALUES (?, ?, ?, ?, ?, ?)
-      `).run(
-        traceIds,
-        insight.type,
-        insight.description,
-        insight.affectedTools ? JSON.stringify(insight.affectedTools) : null,
-        insight.affectedAgents ? JSON.stringify(insight.affectedAgents) : null,
-        insight.confidence,
-      )
-    }
-
-    log.info(`[reflector] Generated ${insights.length} insights`)
-
-    // Trigger curator
-    const { runCurator } = await import("./curator")
-    await runCurator()
-    
-    log.info(`[reflector] Reflection cycle completed successfully`)
-  } catch (err) {
-    log.error(`[reflector] Error during reflection:`, {
-      message: (err as Error).message,
-      stack: (err as Error).stack,
-      errno: (err as any).errno,
-      byteOffset: (err as any).byteOffset,
-      code: (err as any).code,
-    })
-  }
-}
-
-// ─── Local analysis (heuristic, no LLM call needed for basic patterns) ────────
-
-interface Insight {
-  type: "success_pattern" | "failure_pattern" | "optimization" | "ethics_violation"
-  description: string
-  affectedTools?: string[]
-  affectedAgents?: string[]
-  confidence: number
-}
-
-function analyzeTracesLocally(traces: any[]): Insight[] {
-  const insights: Insight[] = []
-
-  // ── Failure patterns ─────────────────────────────────────────────────────
-  const failures = traces.filter((t: any) => !t.success)
-  if (failures.length > 3) {
-    // Group by tool
-    const toolFailures: Record<string, number> = {}
-    for (const f of failures) {
-      if (f.tool_used) {
-        toolFailures[f.tool_used] = (toolFailures[f.tool_used] || 0) + 1
-      }
-    }
-    for (const [tool, count] of Object.entries(toolFailures)) {
-      if (count >= 3) {
-        insights.push({
-          type: "failure_pattern",
-          description: `Tool '${tool}' failed ${count} times recently. Consider verifying its configuration or avoiding it for this type of task.`,
-          affectedTools: [tool],
-          confidence: Math.min(0.9, count / 10),
-        })
-      }
-    }
-  }
-
-  // ── Slow tools ───────────────────────────────────────────────────────────
-  const slowThresholdMs = 5000
-  const slowTools: Record<string, number[]> = {}
-  for (const t of traces) {
-    if (t.tool_used && t.duration_ms > slowThresholdMs) {
-      if (!slowTools[t.tool_used]) slowTools[t.tool_used] = []
-      slowTools[t.tool_used].push(t.duration_ms)
-    }
-  }
-  for (const [tool, durations] of Object.entries(slowTools)) {
-    if (durations.length >= 3) {
-      const avg = Math.round(durations.reduce((a, b) => a + b, 0) / durations.length)
-      insights.push({
-        type: "optimization",
-        description: `Tool '${tool}' is consistently slow (avg ${avg}ms). Cache results when possible or use a faster alternative.`,
-        affectedTools: [tool],
-        confidence: 0.6,
-      })
-    }
-  }
-
-  // ── High success pattern ─────────────────────────────────────────────────
-  const successByTool: Record<string, { ok: number; total: number }> = {}
-  for (const t of traces) {
-    if (!t.tool_used) continue
-    if (!successByTool[t.tool_used]) successByTool[t.tool_used] = { ok: 0, total: 0 }
-    successByTool[t.tool_used].total++
-    if (t.success) successByTool[t.tool_used].ok++
-  }
-  for (const [tool, stats] of Object.entries(successByTool)) {
-    if (stats.total >= 5 && stats.ok / stats.total >= 0.9) {
-      insights.push({
-        type: "success_pattern",
-        description: `Tool '${tool}' has a high success rate (${stats.ok}/${stats.total}). Prefer it for related tasks.`,
-        affectedTools: [tool],
-        confidence: stats.ok / stats.total,
-      })
-    }
-  }
-
-  // ── High token usage ─────────────────────────────────────────────────────
-  const highTokenTraces = traces.filter((t: any) => t.tokens_used > 4000)
-  if (highTokenTraces.length > 3) {
-    insights.push({
-      type: "optimization",
-      description: `${highTokenTraces.length} recent calls used >4000 tokens. Be more concise and use tool results as summaries, not raw dumps.`,
-      confidence: 0.7,
-    })
-  }
-
-  return insights
-}