@johpaz/hive-agents 0.0.35 → 0.0.37

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

@@ -0,0 +1,169 @@
+/**
+ * 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`
+    agentSection += `## CONSULTAS EN MCP, para llamar datos puedes buscar las tools por get o list recors\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

@@ -0,0 +1,204 @@
+/**
+ * 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"
+import type { ContentPart } from "../../multimodal/types"
+
+export type Provider = "openai" | "anthropic" | "gemini" | "mistral" | "kimi" | "ollama" | "openrouter" | "deepseek" | "nvidia"
+
+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 | ContentPart[] }>
+  tools?: Record<string, any>
+  maxSteps?: number
+  onToken?: (token: string) => void
+  onStep?: (step: StepEvent) => Promise<void>
+  threadId?: string
+  userId?: string
+  channel?: string
+  rawUserMessage?: string
+  signal?: AbortSignal
+}
+
+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"] = []
+    let totalInputTokens = 0
+    let totalOutputTokens = 0
+
+    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,
+          },
+          signal: options.signal,
+        }
+      )
+
+      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 
+              : Array.isArray(lastMsg.content)
+                ? lastMsg.content.filter(p => p.type === "text").map(p => (p as any).text).join("\n")
+                : ""
+            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 : "",
+            })
+          }
+        }
+
+        if (chunk.usage) {
+          totalInputTokens += chunk.usage.input_tokens
+          totalOutputTokens += chunk.usage.output_tokens
+        }
+      }
+
+      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: totalInputTokens,
+          completionTokens: totalOutputTokens,
+          totalTokens: totalInputTokens + totalOutputTokens,
+        },
+        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

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

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

@@ -0,0 +1,200 @@
+/**
+ * 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
+}