@johpaz/hive 1.1.0

package/packages/code-bridge/src/schemas.ts

@@ -0,0 +1,133 @@
+import { z } from "zod";
+
+// ─── Agent Roles ────────────────────────────────────────────────────────────
+
+export const AgentRole = z.enum([
+    "architecture",
+    "development",
+    "testing",
+    "documentation",
+]);
+export type AgentRole = z.infer<typeof AgentRole>;
+
+// ─── Subagent Configuration ──────────────────────────────────────────────────
+
+export const SubagentConfig = z.object({
+    role: AgentRole,
+    /** The CLI tool to use for this role (e.g. "opencode", "gemini", "qwen") */
+    cli: z.string(),
+    /** Extra args to pass to the CLI tool */
+    args: z.array(z.string()).default([]),
+    /** Working directory override. Defaults to monorepo root. */
+    cwd: z.string().optional(),
+    /** Max wallclock seconds before the process is auto-killed */
+    timeoutSeconds: z.number().default(600),
+});
+export type SubagentConfig = z.infer<typeof SubagentConfig>;
+
+// ─── Telemetry event shapes sent over the local WebSocket mesh ──────────────
+
+export const TelemetryEventType = z.enum([
+    "agent:started",
+    "agent:output",      // stdout/stderr chunk
+    "agent:progress",    // 0-100 progress hint emitted by the CLI tool
+    "agent:token_usage", // token counters
+    "agent:finished",
+    "agent:error",
+    "agent:cancelled",
+    "code-bridge:status",
+]);
+export type TelemetryEventType = z.infer<typeof TelemetryEventType>;
+
+const BaseEvent = z.object({
+    ts: z.number().default(() => Date.now()),
+    role: AgentRole,
+});
+
+export const AgentStartedEvent = BaseEvent.extend({
+    type: z.literal("agent:started"),
+    pid: z.number(),
+    cli: z.string(),
+    taskId: z.string(),
+});
+
+export const AgentOutputEvent = BaseEvent.extend({
+    type: z.literal("agent:output"),
+    taskId: z.string(),
+    stream: z.enum(["stdout", "stderr"]),
+    chunk: z.string(),
+});
+
+export const AgentProgressEvent = BaseEvent.extend({
+    type: z.literal("agent:progress"),
+    taskId: z.string(),
+    percent: z.number().min(0).max(100),
+});
+
+export const AgentTokenUsageEvent = BaseEvent.extend({
+    type: z.literal("agent:token_usage"),
+    taskId: z.string(),
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    model: z.string(),
+});
+
+export const AgentFinishedEvent = BaseEvent.extend({
+    type: z.literal("agent:finished"),
+    taskId: z.string(),
+    exitCode: z.number(),
+});
+
+export const AgentErrorEvent = BaseEvent.extend({
+    type: z.literal("agent:error"),
+    taskId: z.string(),
+    message: z.string(),
+});
+
+export const AgentCancelledEvent = BaseEvent.extend({
+    type: z.literal("agent:cancelled"),
+    taskId: z.string(),
+});
+
+export const CodeBridgeStatusEvent = z.object({
+    type: z.literal("code-bridge:status"),
+    ts: z.number().default(() => Date.now()),
+    agents: z.array(
+        z.object({
+            taskId: z.string(),
+            role: AgentRole,
+            cli: z.string(),
+            pid: z.number(),
+            state: z.enum(["running", "finished", "cancelled", "error"]),
+            progress: z.number(),
+            tokens: z.object({ input: z.number(), output: z.number() }),
+            model: z.string().optional(),
+        })
+    ),
+});
+
+export const TelemetryEvent = z.discriminatedUnion("type", [
+    AgentStartedEvent,
+    AgentOutputEvent,
+    AgentProgressEvent,
+    AgentTokenUsageEvent,
+    AgentFinishedEvent,
+    AgentErrorEvent,
+    AgentCancelledEvent,
+    CodeBridgeStatusEvent,
+]);
+export type TelemetryEvent = z.infer<typeof TelemetryEvent>;
+
+// ─── Dashboard → Code Bridge commands ──────────────────────────────────────
+
+export const DashboardCommand = z.discriminatedUnion("cmd", [
+    z.object({
+        cmd: z.literal("launch"),
+        config: SubagentConfig,
+        taskId: z.string(),
+        prompt: z.string(),
+    }),
+    z.object({ cmd: z.literal("cancel"), taskId: z.string() }),
+    z.object({ cmd: z.literal("status") }),
+]);
+export type DashboardCommand = z.infer<typeof DashboardCommand>;

package/packages/core/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@johpaz/hive-core",
+  "version": "1.1.0",
+  "private": true,
+  "description": "Hive Gateway — Personal AI agent runtime",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "types": "./src/index.ts",
+  "license": "MIT",
+  "files": [
+    "src/"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@ag-ui/core": "^0.0.46",
+    "@johpaz/hive-mcp": "^1.1.0",
+    "@johpaz/hive-skills": "^1.1.0",
+    "@modelcontextprotocol/sdk": "latest",
+    "@sapphire/snowflake": "latest",
+    "@slack/bolt": "latest",
+    "@whiskeysockets/baileys": "latest",
+    "croner": "^10.0.1",
+    "discord.js": "latest",
+    "grammy": "latest",
+    "js-yaml": "latest",
+    "qrcode-terminal": "latest",
+    "toon-format-parser": "1.1.3",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "typescript": "latest",
+    "@types/bun": "latest"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./gateway": "./src/gateway/index.ts",
+    "./agent": "./src/agent/index.ts",
+    "./channels": "./src/channels/index.ts",
+    "./config": "./src/config/loader.ts",
+    "./utils": "./src/utils/logger.ts",
+    "./storage/sqlite": "./src/storage/sqlite.ts"
+  }
+}

package/packages/core/src/agent/agent-loop.ts

@@ -0,0 +1,369 @@
+/**
+ * Agent Loop — native implementation, no LangGraph.
+ *
+ * Replaces supervisor.ts + graph.ts.
+ *
+ * Pattern:
+ *   user message → context compiler → model call → [tool call → model call]* → response
+ *
+ * Exposes an async generator compatible with the existing providers/index.ts stream API:
+ *   yield { agent: { messages: [AIMessage] } }
+ *   yield { tools: { messages: [ToolMessage] } }
+ *
+ * Also used directly by runAgentIsolated() for worker tasks.
+ */
+
+import { logger } from "../utils/logger"
+import { getDb } from "../storage/sqlite"
+import { callLLM, resolveProviderConfig, type LLMMessage } from "./llm-client"
+import { compileContext } from "./context-compiler"
+import { executeTool } from "./native-tools"
+import {
+  addMessage,
+  getRecentMessages,
+  toAPIMessages,
+} from "./conversation-store"
+import { saveTrace, recordLLMUsage } from "./tracer"
+import { maybeCompact, clearOldToolResults } from "./compaction"
+import { emitCanvas } from "../canvas/emitter"
+import type { MCPClientManager } from "@johpaz/hive-mcp"
+
+const log = logger.child("agent-loop")
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface AgentLoopOptions {
+  agentId: string
+  userMessage: string
+  threadId: string
+  channel?: string
+  mcpManager?: MCPClientManager | null
+  /** System prompt override (from server.ts config) */
+  systemPromptOverride?: string
+  /** Worker mode: isolated context + single-task execution */
+  isolated?: boolean
+  taskContext?: string
+  onStep?: (step: StepEvent) => Promise<void>
+}
+
+export interface StepEvent {
+  type: "text" | "tool_call" | "tool_result"
+  message: string
+  toolName?: string
+  isError?: boolean
+}
+
+// ─── Stream chunk types (compatible with providers/index.ts) ─────────────────
+
+export interface StreamChunk {
+  agent?: { messages: any[] }
+  tools?: { messages: any[] }
+}
+
+// ─── Main agent loop ──────────────────────────────────────────────────────────
+
+export async function* runAgent(
+  opts: AgentLoopOptions
+): AsyncGenerator<StreamChunk> {
+  const t0 = performance.now()
+  const db = getDb()
+
+  // Load agent config from DB
+  const agent = db.query<any, [string]>("SELECT * FROM agents WHERE id = ?").get(opts.agentId)
+  if (!agent) throw new Error(`Agent not found: ${opts.agentId}`)
+
+  const agentName = agent.name || opts.agentId
+  const maxIterations = agent.max_iterations || 10
+
+  // Resolve LLM provider config
+  const providerCfg = await resolveProviderConfig(
+    agent.provider_id || "openai",
+    agent.model_id || "gpt-4o-mini"
+  )
+
+  const cleanModel = providerCfg.model.replace(new RegExp(`^${providerCfg.provider}\\/`), "")
+  log.info(`[agent-loop] Starting: agent=${agentName} thread=${opts.threadId} provider=${providerCfg.provider}/${cleanModel}`)
+
+  emitCanvas("canvas:node_update", {
+    nodeId: agentName,
+    changes: { status: "thinking" },
+  })
+
+  // Store the user message in conversation history
+  if (!opts.isolated) {
+    addMessage(opts.threadId, "user", opts.userMessage, { channel: opts.channel })
+    // Run compaction if conversation history is getting large
+    await maybeCompact(opts.threadId)
+  }
+
+  // Compile context (system prompt + history + tools)
+  const ctx = await compileContext({
+    agentId: opts.agentId,
+    threadId: opts.threadId,
+    userMessage: opts.userMessage,
+    channel: opts.channel,
+    mcpManager: opts.mcpManager,
+    isolated: opts.isolated,
+    taskContext: opts.taskContext,
+  })
+
+  const systemPrompt = opts.systemPromptOverride || ctx.systemPrompt
+
+  // Build initial messages array for the model
+  let messages: LLMMessage[] = [
+    { role: "system", content: systemPrompt },
+    ...ctx.messages,
+  ]
+
+  // For isolated workers the user message is the task context, not from history
+  if (opts.isolated) {
+    messages.push({ role: "user", content: opts.userMessage })
+  }
+
+  let iterations = 0
+  let totalInputTokens = 0
+  let totalOutputTokens = 0
+  let finalContent = ""
+
+  // ── The loop ────────────────────────────────────────────────────────────
+  while (iterations < maxIterations) {
+    iterations++
+
+    const response = await callLLM({
+      ...providerCfg,
+      messages: clearOldToolResults(messages) as LLMMessage[],
+      tools: ctx.tools.length > 0 ? ctx.tools : undefined,
+    })
+
+    // Accumulate usage
+    if (response.usage) {
+      totalInputTokens += response.usage.input_tokens
+      totalOutputTokens += response.usage.output_tokens
+    }
+
+    // Emit agent chunk (compatible with providers/index.ts)
+    const agentMsg: any = { content: response.content }
+    if (response.tool_calls?.length) agentMsg.tool_calls = response.tool_calls
+    yield { agent: { messages: [agentMsg] } }
+
+    // Notify onStep for narration text
+    if (opts.onStep && response.content) {
+      await opts.onStep({ type: "text", message: response.content })
+    }
+
+    // ── No tool calls → final response ──────────────────────────────────
+    if (!response.tool_calls?.length || response.stop_reason !== "tool_calls") {
+      finalContent = response.content
+      // Save assistant message to history
+      if (!opts.isolated) {
+        addMessage(opts.threadId, "assistant", response.content)
+      }
+      break
+    }
+
+    // ── Tool calls → execute each tool ──────────────────────────────────
+    // Add assistant message with tool_calls to local messages array
+    messages.push({
+      role: "assistant",
+      content: response.content,
+      tool_calls: response.tool_calls,
+    })
+
+    for (const tc of response.tool_calls) {
+      const toolName = tc.function.name
+
+      emitCanvas("canvas:node_update", {
+        nodeId: agentName,
+        changes: { status: "tool_call", currentTool: toolName },
+      })
+
+      if (opts.onStep) {
+        if (response.content) {
+          await opts.onStep({ type: "text", message: response.content })
+        }
+        await opts.onStep({
+          type: "tool_call",
+          toolName,
+          message: `Calling tool: \`${toolName}\``,
+        })
+      }
+
+      const tTool = performance.now()
+      const toolResult = await executeTool(
+        ctx.allTools,
+        toolName,
+        tc.function.arguments,
+        {
+          user_id: process.env.HIVE_USER_ID || "",
+          thread_id: opts.threadId,
+          channel: opts.channel,
+        }
+      )
+      const toolMs = Math.round(performance.now() - tTool)
+
+      log.info(`[agent-loop] Tool ${toolName} completed in ${toolMs}ms`)
+
+      // Save tool call trace
+      saveTrace({
+        threadId: opts.threadId,
+        agentId: opts.agentId,
+        agentName,
+        toolUsed: toolName,
+        inputSummary: `${opts.userMessage.substring(0, 200)} → ${toolName}`,
+        outputSummary: toolResult.substring(0, 300),
+        success: !toolResult.startsWith("[Tool Error]"),
+        errorMessage: toolResult.startsWith("[Tool Error]") ? toolResult : null,
+        durationMs: toolMs,
+      })
+
+      // Emit tool chunk
+      yield { tools: { messages: [{ content: toolResult, tool_call_id: tc.id }] } }
+
+      if (opts.onStep) {
+        await opts.onStep({ type: "tool_result", message: toolResult })
+      }
+
+      // Add tool result to messages for next model call
+      messages.push({
+        role: "tool",
+        content: toolResult,
+        tool_call_id: tc.id,
+      })
+    }
+
+    emitCanvas("canvas:node_update", {
+      nodeId: agentName,
+      changes: { status: "thinking", currentTool: null },
+    })
+  }
+
+  // ── Post-loop ────────────────────────────────────────────────────────────
+  const durationMs = Math.round(performance.now() - t0)
+
+  emitCanvas("canvas:node_update", {
+    nodeId: agentName,
+    changes: { status: "idle", currentTool: null },
+  })
+
+  // Record usage
+  recordLLMUsage({
+    provider: providerCfg.provider,
+    model: providerCfg.model,
+    inputTokens: totalInputTokens,
+    outputTokens: totalOutputTokens,
+  })
+
+  // Save overall trace
+  saveTrace({
+    threadId: opts.threadId,
+    agentId: opts.agentId,
+    agentName,
+    inputSummary: opts.userMessage.substring(0, 300),
+    outputSummary: finalContent.substring(0, 300),
+    success: true,
+    durationMs,
+    tokensUsed: totalInputTokens + totalOutputTokens,
+  })
+
+  log.info(
+    `[agent-loop] Done: agent=${agentName} iterations=${iterations} ` +
+    `tokens=${totalInputTokens + totalOutputTokens} elapsed=${durationMs}ms`
+  )
+}
+
+// ─── Isolated worker execution (Fase 4.4) ───────────────────────────────────
+
+/**
+ * Run a worker agent in an isolated context.
+ * Returns the final response string.
+ */
+export async function runAgentIsolated(opts: {
+  agentId: string
+  taskDescription: string
+  threadId: string
+  mcpManager?: MCPClientManager | null
+}): Promise<string> {
+  let lastContent = ""
+  for await (const chunk of runAgent({
+    agentId: opts.agentId,
+    userMessage: opts.taskDescription,
+    threadId: opts.threadId,
+    isolated: true,
+    taskContext: opts.taskDescription,
+    mcpManager: opts.mcpManager,
+  })) {
+    if (chunk.agent?.messages?.[0]?.content) {
+      lastContent = chunk.agent.messages[0].content
+    }
+  }
+  return lastContent
+}
+
+// ─── Shim: AgentLoop class with stream() compatible with providers/index.ts ──
+
+export class AgentLoop {
+  private mcpManager: MCPClientManager | null = null
+
+  setMCPManager(m: MCPClientManager) {
+    this.mcpManager = m
+  }
+
+  /**
+   * Returns an async iterable that emits chunks compatible with
+   * the existing providers/index.ts stream consumer.
+   */
+  stream(
+    input: { messages: Array<{ role: string; content: string }> },
+    config: {
+      configurable?: {
+        thread_id?: string
+        agent_id?: string
+        user_id?: string
+        system_prompt?: string
+        channel?: string
+      }
+    }
+  ): AsyncIterable<StreamChunk> {
+    const threadId = config.configurable?.thread_id || process.env.HIVE_USER_ID || "default"
+    const agentId = config.configurable?.agent_id || this._resolveCoordinatorId()
+    const systemPromptOverride = config.configurable?.system_prompt
+    const channel = config.configurable?.channel
+
+    // Extract the last user message from the input
+    const lastUserMsg = [...input.messages].reverse().find((m) => m.role === "user")
+    const userMessage = lastUserMsg?.content || ""
+
+    return runAgent({
+      agentId,
+      userMessage,
+      threadId,
+      channel,
+      systemPromptOverride,
+      mcpManager: this.mcpManager,
+    })
+  }
+
+  private _resolveCoordinatorId(): string {
+    try {
+      const { getDb } = require("../storage/sqlite")
+      const db = getDb()
+      const row = db.query("SELECT id FROM agents WHERE is_coordinator = 1 LIMIT 1").get() as any
+      return row?.id || process.env.HIVE_AGENT_ID || "main"
+    } catch {
+      return process.env.HIVE_AGENT_ID || "main"
+    }
+  }
+}
+
+// Singleton
+let _agentLoop: AgentLoop | null = null
+
+export function getAgentLoop(): AgentLoop | null {
+  return _agentLoop
+}
+
+export function buildAgentLoop(opts: { mcpManager?: MCPClientManager | null } = {}): AgentLoop {
+  _agentLoop = new AgentLoop()
+  if (opts.mcpManager) _agentLoop.setMCPManager(opts.mcpManager)
+  return _agentLoop
+}

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

@@ -0,0 +1,140 @@
+/**
+ * Compaction — Fase 6.
+ *
+ * Compresses conversation history when token count exceeds threshold.
+ * Uses the active LLM to summarize old messages, preserving:
+ *   - User data and preferences
+ *   - Decisions made
+ *   - Tool results
+ *   - Context needed to continue
+ *
+ * Saves summary to `summaries` table. Original messages are kept (audit trail)
+ * but the Context Compiler uses the summary instead of old messages.
+ *
+ * Also implements "tool result clearing": replaces old tool results with
+ * short summaries in the in-memory message array before model calls.
+ */
+
+import { logger } from "../utils/logger"
+import {
+  getTotalTokens,
+  getHistory,
+  getSummary,
+  saveSummary,
+  toAPIMessages,
+  estimateTokens,
+  getMessageCount,
+} from "./conversation-store"
+import { callLLM, resolveProviderConfig } from "./llm-client"
+import { getDb } from "../storage/sqlite"
+
+const log = logger.child("compaction")
+
+// Token budget: compress when stored tokens exceed this threshold
+const COMPACT_TOKEN_THRESHOLD = 6000   // ~60% of 10K context window
+const KEEP_LAST_N_MESSAGES = 5         // always keep most recent N messages
+const TOOL_RESULT_MAX_CHARS = 200      // max chars for old tool results after clearing
+const MAX_TRANSCRIPT_MSGS = 30         // cap messages sent to summarizer (avoids OOM on small models)
+const MAX_MSG_CHARS = 300              // chars per message in transcript
+
+/**
+ * Check if compaction is needed and run it if so.
+ * Called at the start of each agent loop iteration.
+ */
+export async function maybeCompact(threadId: string): Promise<void> {
+  try {
+    const totalTokens = getTotalTokens(threadId)
+    if (totalTokens < COMPACT_TOKEN_THRESHOLD) return
+
+    const summary = getSummary(threadId)
+    const totalMessages = getMessageCount(threadId)
+
+    // Already summarized up to near the current state
+    if (summary && summary.last_message_id > totalMessages - KEEP_LAST_N_MESSAGES) return
+
+    log.info(`[compaction] Compacting thread=${threadId} tokens=${totalTokens}`)
+    await compactThread(threadId)
+  } catch (err) {
+    log.warn("[compaction] Error during compaction check:", err)
+  }
+}
+
+/**
+ * Compress a thread's history into a summary.
+ */
+export async function compactThread(threadId: string): Promise<void> {
+  const allMessages = getHistory(threadId)
+  if (allMessages.length <= KEEP_LAST_N_MESSAGES) return
+
+  const toSummarize = allMessages.slice(0, allMessages.length - KEEP_LAST_N_MESSAGES)
+  if (toSummarize.length === 0) return
+
+  const lastSummarizedId = toSummarize[toSummarize.length - 1].id
+
+  const existingSummary = getSummary(threadId)
+  if (existingSummary && existingSummary.last_message_id >= lastSummarizedId) return
+
+  // Cap transcript to avoid overflowing small model contexts
+  const capped = toSummarize.slice(-MAX_TRANSCRIPT_MSGS)
+  const apiMessages = toAPIMessages(capped)
+  const transcript = apiMessages
+    .map((m) => `[${m.role.toUpperCase()}]: ${m.content.substring(0, MAX_MSG_CHARS)}`)
+    .join("\n\n")
+
+  const db = getDb()
+  const coordinator = db.query<any, []>(
+    "SELECT provider_id, model_id FROM agents WHERE is_coordinator = 1 LIMIT 1"
+  ).get()
+
+  const providerCfg = await resolveProviderConfig(
+    coordinator?.provider_id || "openai",
+    coordinator?.model_id || "gpt-4o-mini"
+  )
+
+  const summaryResponse = await callLLM({
+    ...providerCfg,
+    messages: [
+      {
+        role: "system",
+        content:
+          "You are a conversation summarizer. Create a concise summary preserving: " +
+          "user preferences, decisions made, important facts, tool results, and context needed to continue.",
+      },
+      {
+        role: "user",
+        content: `Summarize this conversation (${toSummarize.length} messages) in 3-5 sentences:\n\n${transcript}`,
+      },
+    ],
+  })
+
+  const summary = summaryResponse.content.trim()
+  if (!summary) return
+
+  saveSummary(threadId, summary, toSummarize.length, lastSummarizedId)
+  log.info(
+    `[compaction] Thread ${threadId} compacted: ${toSummarize.length} msgs → ${estimateTokens(summary)} tokens`
+  )
+}
+
+/**
+ * Clear old tool results in-memory to reduce tokens before a model call.
+ * Does NOT modify the database — only the in-memory messages array.
+ */
+export function clearOldToolResults<T extends { role: string; content: string }>(
+  messages: T[],
+  keepLastN = 6
+): T[] {
+  if (messages.length <= keepLastN) return messages
+  const cutoffIndex = messages.length - keepLastN
+
+  return messages.map((msg, i) => {
+    if (i >= cutoffIndex) return msg
+    if (msg.role === "tool" && msg.content.length > TOOL_RESULT_MAX_CHARS) {
+      return {
+        ...msg,
+        content: `[Result truncated: ${msg.content.substring(0, TOOL_RESULT_MAX_CHARS)}...]`,
+      }
+    }
+    return msg
+  })
+}