@johpaz/hive-sdk 0.1.6 → 0.3.0

package/test/context-compiler.test.ts

@@ -1,269 +0,0 @@
-/**
- * context-compiler tests: G9 causal context window (buildAgentContext).
- *
- * Exercises the real compileContext() path with a real (in-memory) HiveDB —
- * only the pieces that would otherwise need network/process I/O
- * (MCP manager, native tool executors) are left at their defaults since
- * createAllTools() works standalone in-process.
- */
-
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { closeHiveDb, getHiveDb } from "../packages/core/src/storage/hivedb";
-import { ensureHiveDb } from "../packages/core/src/storage/bootstrap";
-import { resetBootId } from "../packages/core/src/storage/boot-id";
-import { col, toIndexable } from "../packages/core/src/storage/hive";
-import { addMessage, saveSummary } from "../packages/core/src/agent/conversation-store";
-import { compileContext } from "../packages/core/src/agent/context-compiler";
-import type { AgentDoc, ModelDoc, ProviderDoc, UserDoc } from "../packages/core/src/storage/collections";
-
-async function seedAgentWithSmallContextWindow() {
-  const usersCol = await col<UserDoc>("users");
-  await usersCol.put("test-user", {
-    id: "test-user",
-    name: "Test User",
-    language: "es",
-    timezone: null,
-    occupation: null,
-    notes: null,
-    master_key_hash: null,
-    email: null,
-    password_hash: null,
-    preferred_cron_channel: "webchat",
-    created_at: Date.now(),
-  });
-
-  const agentsCol = await col<AgentDoc>("agents");
-  await agentsCol.put("test-agent", {
-    id: "test-agent",
-    user_id: "test-user",
-    name: "Test Agent",
-    description: null,
-    system_prompt: "Eres un agente de prueba.",
-    tone: null,
-    role: "coordinator",
-    status: "idle",
-    enabled: true,
-    provider_id: toIndexable("hiveagents"),
-    model_id: toIndexable("test-model"),
-    tools_json: null,
-    skills_json: null,
-    parent_id: toIndexable(null),
-    max_iterations: 10,
-    workspace: null,
-    lastTraceAt: null,
-    created_at: Date.now(),
-    updated_at: Date.now(),
-  });
-
-  const providersCol = await col<ProviderDoc>("providers");
-  await providersCol.put("hiveagents", {
-    id: "hiveagents",
-    name: "HiveAgents",
-    enabled: true,
-    active: true,
-    base_url: "https://fake.api.com/v1",
-    category: "llm",
-    num_ctx: null,
-    num_gpu: 0,
-    created_at: Date.now(),
-  });
-
-  // Small context window so a handful of messages is enough to cross
-  // compactThreshold (window * 0.8) and force the summary/compaction path.
-  const modelsCol = await col<ModelDoc>("models");
-  await modelsCol.put("test-model", {
-    id: "test-model",
-    provider_id: "hiveagents",
-    name: "Test Model",
-    model_type: "llm",
-    active: true,
-    enabled: true,
-    context_window: 1000,
-    capabilities: null,
-  });
-}
-
-// KEEP_LAST_N_MESSAGES in context-compiler.ts is 30 — insert enough messages
-// that the recent-messages window is a strict suffix starting AFTER the
-// summary's last_message_id. That's what makes a summary "apply": the window
-// no longer reaches back far enough to cover what the summary already does.
-async function forceCompaction(threadId: string) {
-  for (let i = 0; i < 35; i++) {
-    await addMessage(threadId, i % 2 === 0 ? "user" : "assistant", `msg-${i}`);
-  }
-  await saveSummary(threadId, "Resumen de la conversación previa.", 5, 5);
-}
-
-beforeEach(async () => {
-  closeHiveDb();
-  resetBootId();
-  await ensureHiveDb();
-  await seedAgentWithSmallContextWindow();
-});
-
-afterEach(() => {
-  closeHiveDb();
-  delete process.env.HIVE_CAUSAL_LOG;
-});
-
-describe("context-compiler: G9 causal context window", () => {
-  test("injects a # CAUSAL CONTEXT section once compaction fires and a causal stream has decisions", async () => {
-    process.env.HIVE_CAUSAL_LOG = "true";
-    const db = await getHiveDb();
-
-    const streamId = "ctx-stream-1";
-    const intentSeq = await db.append({
-      agentId: "test-agent",
-      streamId,
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "test-agent", intent: "deploy the checkout service" }),
-    });
-    await db.append({
-      agentId: "test-agent",
-      streamId,
-      kind: "StateTransition",
-      payload: JSON.stringify({ description: "Calling deploy_service on checkout" }),
-      causation: intentSeq,
-    });
-
-    await forceCompaction("thread-ctx-1");
-
-    const ctx = await compileContext({
-      agentId: "test-agent",
-      threadId: "thread-ctx-1",
-      userMessage: "Seguí con el deploy",
-      causalStreamId: streamId,
-    });
-
-    expect(ctx.systemPrompt).toContain("# CAUSAL CONTEXT");
-    expect(ctx.systemPrompt).toContain("Calling deploy_service on checkout");
-  });
-
-  test("does not inject a causal context section when causalLog is disabled", async () => {
-    process.env.HIVE_CAUSAL_LOG = "false";
-    const db = await getHiveDb();
-
-    const streamId = "ctx-stream-2";
-    const intentSeq = await db.append({
-      agentId: "test-agent",
-      streamId,
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "test-agent", intent: "deploy the checkout service" }),
-    });
-    await db.append({
-      agentId: "test-agent",
-      streamId,
-      kind: "StateTransition",
-      payload: JSON.stringify({ description: "Calling deploy_service on checkout" }),
-      causation: intentSeq,
-    });
-
-    await forceCompaction("thread-ctx-2");
-
-    const ctx = await compileContext({
-      agentId: "test-agent",
-      threadId: "thread-ctx-2",
-      userMessage: "Seguí con el deploy",
-      causalStreamId: streamId,
-    });
-
-    expect(ctx.systemPrompt).not.toContain("# CAUSAL CONTEXT");
-  });
-
-  test("does not inject a causal context section when compaction hasn't fired", async () => {
-    process.env.HIVE_CAUSAL_LOG = "true";
-    const db = await getHiveDb();
-
-    const streamId = "ctx-stream-3";
-    const intentSeq = await db.append({
-      agentId: "test-agent",
-      streamId,
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "test-agent", intent: "deploy the checkout service" }),
-    });
-    await db.append({
-      agentId: "test-agent",
-      streamId,
-      kind: "StateTransition",
-      payload: JSON.stringify({ description: "Calling deploy_service on checkout" }),
-      causation: intentSeq,
-    });
-
-    // No forceCompaction() call — conversation is short, no summary exists.
-
-    const ctx = await compileContext({
-      agentId: "test-agent",
-      threadId: "thread-ctx-3",
-      userMessage: "Hola",
-      causalStreamId: streamId,
-    });
-
-    expect(ctx.systemPrompt).not.toContain("# CAUSAL CONTEXT");
-  });
-});
-
-describe("context-compiler: conversation summary + internal events", () => {
-  test("folds the summary into systemPrompt as # RESUMEN DE LA CONVERSACIÓN when it applies", async () => {
-    await forceCompaction("thread-summary-1");
-
-    const ctx = await compileContext({
-      agentId: "test-agent",
-      threadId: "thread-summary-1",
-      userMessage: "Continuemos",
-    });
-
-    expect(ctx.systemPrompt).toContain("# RESUMEN DE LA CONVERSACIÓN");
-    expect(ctx.systemPrompt).toContain("Resumen de la conversación previa.");
-    expect(ctx.conversationSummarySection).not.toBe("");
-  });
-
-  test("does not include a summary section when none applies", async () => {
-    await addMessage("thread-summary-2", "user", "Hola");
-
-    const ctx = await compileContext({
-      agentId: "test-agent",
-      threadId: "thread-summary-2",
-      userMessage: "Hola de nuevo",
-    });
-
-    expect(ctx.systemPrompt).not.toContain("# RESUMEN DE LA CONVERSACIÓN");
-    expect(ctx.conversationSummarySection).toBe("");
-  });
-
-  test("never emits a second role:system message in ctx.messages, even when a summary applies", async () => {
-    await forceCompaction("thread-summary-3");
-
-    const ctx = await compileContext({
-      agentId: "test-agent",
-      threadId: "thread-summary-3",
-      userMessage: "Continuemos",
-    });
-
-    expect(ctx.messages.every((m) => m.role !== "system")).toBe(true);
-  });
-
-  test("an internal event keeps its chronological position and role:user in ctx.messages", async () => {
-    const threadId = "thread-internal-1";
-    await addMessage(threadId, "user", "Delegá esto a un worker");
-    await addMessage(threadId, "assistant", "Listo, delegado.");
-    await addMessage(threadId, "user", "El agente completó la tarea X.", { source: "task_complete" });
-    await addMessage(threadId, "assistant", "El worker terminó la tarea X exitosamente.");
-
-    const ctx = await compileContext({
-      agentId: "test-agent",
-      threadId,
-      userMessage: "¿Cómo va todo?",
-    });
-
-    expect(ctx.messages.every((m) => m.role !== "system")).toBe(true);
-
-    const idx = ctx.messages.findIndex(
-      (m) => typeof m.content === "string" && m.content.includes("hive:internal_event")
-    );
-    expect(idx).toBeGreaterThan(0);
-    expect(idx).toBeLessThan(ctx.messages.length - 1);
-    expect(ctx.messages[idx].role).toBe("user");
-  });
-});

package/test/curator.test.ts

@@ -1,130 +0,0 @@
-/**
- * Curator tests: baseline regression coverage for the existing
- * reflection → playbook pipeline (none existed before), plus the new
- * category mapping for G9 evaluateHarness() insight types
- * (root_cause/learning_proposal — see reflector.ts's analyzeCausalThreads).
- */
-
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { closeHiveDb } from "../packages/core/src/storage/hivedb";
-import { ensureHiveDb } from "../packages/core/src/storage/bootstrap";
-import { resetBootId } from "../packages/core/src/storage/boot-id";
-import { col, nextId } from "../packages/core/src/storage/hive";
-import type { ReflectionDoc, PlaybookDoc } from "../packages/core/src/storage/collections";
-import { runCurator } from "../packages/core/src/agent/curator";
-
-async function seedReflection(overrides: Partial<ReflectionDoc>) {
-  const reflectionsCol = await col<ReflectionDoc>("reflections");
-  const id = await nextId("reflections");
-  await reflectionsCol.put(id, {
-    id,
-    trace_ids: "[]",
-    insight_type: "failure_pattern",
-    description: "Tool 'flaky_tool' failed 5 times recently.",
-    affected_tools: null,
-    affected_agents: null,
-    confidence: 0.5,
-    created_at: Date.now(),
-    ...overrides,
-  });
-  return id;
-}
-
-beforeEach(async () => {
-  closeHiveDb();
-  resetBootId();
-  await ensureHiveDb();
-});
-
-afterEach(() => {
-  closeHiveDb();
-});
-
-describe("curator: baseline reflection → playbook pipeline", () => {
-  test("a new reflection creates a new active playbook rule", async () => {
-    await seedReflection({ description: "Tool 'flaky_tool' failed 5 times recently." });
-
-    await runCurator();
-
-    const playbookCol = await col<PlaybookDoc>("playbook");
-    const all = await playbookCol.scan({});
-    const rule = all.find((e) => e.doc.rule === "Tool 'flaky_tool' failed 5 times recently.");
-    expect(rule).toBeDefined();
-    expect(rule!.doc.category).toBe("error_avoidance");
-    expect(rule!.doc.helpful_count).toBe(1);
-    expect(rule!.doc.harmful_count).toBe(0);
-    expect(rule!.doc.active).toBe(true);
-  });
-
-  test("a reflection matching an existing rule's prefix reinforces it instead of duplicating", async () => {
-    const description = "Tool 'flaky_tool' failed 5 times recently. Consider verifying its configuration.";
-    await seedReflection({ description });
-    await runCurator();
-
-    // Second, near-identical reflection (same first-60-chars prefix)
-    await seedReflection({ description: description + " Extra detail." });
-    await runCurator();
-
-    const playbookCol = await col<PlaybookDoc>("playbook");
-    const all = await playbookCol.scan({});
-    const matching = all.filter((e) => e.doc.rule.startsWith(description.substring(0, 60)));
-    expect(matching.length).toBe(1);
-    expect(matching[0].doc.helpful_count).toBe(2);
-  });
-
-  test("a rule with harmful_count >= 3 and > helpful_count is deactivated on the next curator run", async () => {
-    const playbookCol = await col<PlaybookDoc>("playbook");
-    const now = Date.now();
-    await playbookCol.put("bad-rule", {
-      id: "bad-rule",
-      rule: "This rule turned out to be harmful.",
-      category: "optimization",
-      applicable_to: null,
-      helpful_count: 1,
-      harmful_count: 3,
-      active: true,
-      source_reflection_id: "NO_PARENT",
-      created_at: now,
-      updated_at: now,
-    }, { expectedVersion: 0 });
-
-    await runCurator();
-
-    const entry = await playbookCol.get("bad-rule");
-    expect(entry!.doc.active).toBe(false);
-  });
-});
-
-describe("curator: G9 evaluateHarness() insight category mapping", () => {
-  test("root_cause insights map to the error_avoidance category", async () => {
-    await seedReflection({
-      insight_type: "root_cause",
-      description: "Root cause in stream s1: called deploy_prod without running tests first.",
-    });
-
-    await runCurator();
-
-    const playbookCol = await col<PlaybookDoc>("playbook");
-    const all = await playbookCol.scan({});
-    const rule = all.find((e) => e.doc.rule.startsWith("Root cause in stream s1"));
-    expect(rule).toBeDefined();
-    expect(rule!.doc.category).toBe("error_avoidance");
-  });
-
-  test("learning_proposal insights map to the response_quality category", async () => {
-    await seedReflection({
-      insight_type: "learning_proposal",
-      description: "Add pre-checks before calling tool 'flaky_tool' to avoid repeated errors",
-    });
-
-    await runCurator();
-
-    const playbookCol = await col<PlaybookDoc>("playbook");
-    const all = await playbookCol.scan({});
-    const rule = all.find((e) => e.doc.rule.startsWith("Add pre-checks before calling tool"));
-    expect(rule).toBeDefined();
-    expect(rule!.doc.category).toBe("response_quality");
-  });
-});

package/test/durable-queue.test.ts

@@ -1,114 +0,0 @@
-/**
- * Tests: DurableLaneQueue — dispatch, boot re-dispatch, forced reclaim.
- *
- * 1. enqueue → dispatch → executor runs → job completed
- * 2. start() dispatches jobs left pending by a previous boot
- * 3. reconcileOnBoot reclaims "running" jobs immediately (single-process:
- *    any running row at boot belongs to a dead process, lease ignored)
- * 4. reclaimOrInterrupt force interrupts when attempts are exhausted
- */
-
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { closeHiveDb } from "../packages/core/src/storage/hivedb";
-import { ensureHiveDb } from "../packages/core/src/storage/bootstrap";
-import { resetBootId, getBootId } from "../packages/core/src/storage/boot-id";
-import { DurableLaneQueue, registerExecutor } from "../packages/core/src/gateway/durable-queue";
-import { createJob, claimJob, getJob, reclaimOrInterrupt } from "../packages/core/src/gateway/job-store";
-import { reconcileOnBoot } from "../packages/core/src/storage/reconcile";
-
-let queue: DurableLaneQueue | null = null;
-
-beforeEach(async () => {
-  closeHiveDb();
-  resetBootId();
-  await ensureHiveDb();
-});
-
-afterEach(() => {
-  queue?.stop();
-  queue = null;
-  closeHiveDb();
-});
-
-async function waitFor(predicate: () => Promise<boolean>, timeoutMs = 3000): Promise<void> {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    if (await predicate()) return;
-    await new Promise((r) => setTimeout(r, 25));
-  }
-  throw new Error("waitFor timed out");
-}
-
-describe("durable-queue: dispatch + reclaim", () => {
-  test("enqueue dispatches the job and persists the executor result", async () => {
-    const executed: string[] = [];
-    registerExecutor("worker_task", async (job) => {
-      executed.push(job.id);
-      return { ok: true, result: "done!" };
-    });
-
-    queue = new DurableLaneQueue({ maxGlobalConcurrency: 2 });
-    const job = await queue.enqueue({
-      lane: "task:test-1",
-      type: "worker_task",
-      run_id: "run-x",
-      payload: { hello: "world" },
-    });
-
-    await waitFor(async () => (await getJob(job.id))?.status === "completed");
-
-    const finished = await getJob(job.id);
-    expect(executed).toContain(job.id);
-    expect(finished!.status).toBe("completed");
-    expect(JSON.parse(finished!.result_json!)).toBe("done!");
-    expect(finished!.boot_id).toBeNull();
-  });
-
-  test("start() re-dispatches jobs left pending by a previous boot", async () => {
-    const executed: string[] = [];
-    registerExecutor("worker_task", async (job) => {
-      executed.push(job.id);
-      return { ok: true, result: null };
-    });
-
-    // Jobs created directly (as if the process died right after enqueue)
-    const j1 = await createJob({ lane: "task:a", type: "worker_task", payload: {}, run_id: "r1" });
-    const j2 = await createJob({ lane: "task:b", type: "worker_task", payload: {}, run_id: "r2" });
-
-    queue = new DurableLaneQueue({ maxGlobalConcurrency: 2 });
-    queue.start();
-
-    await waitFor(async () =>
-      (await getJob(j1.id))?.status === "completed" && (await getJob(j2.id))?.status === "completed"
-    );
-    expect(executed.sort()).toEqual([j1.id, j2.id].sort());
-  });
-
-  test("reconcileOnBoot reclaims a running job immediately, ignoring its lease", async () => {
-    const job = await createJob({ lane: "task:c", type: "worker_task", payload: {}, run_id: "r3" });
-    const claimed = await claimJob(job.id, "dead-boot");
-    expect(claimed!.status).toBe("running");
-    // Lease is still fresh (30 min) — at boot it must be reclaimed anyway
-    expect(claimed!.lease_expires_at! > Date.now()).toBe(true);
-
-    await reconcileOnBoot(getBootId());
-
-    const after = await getJob(job.id);
-    expect(after!.status).toBe("pending");
-    expect(after!.boot_id).toBeNull();
-    expect(after!.attempts).toBe(1);
-  });
-
-  test("forced reclaim interrupts the job when attempts are exhausted", async () => {
-    const job = await createJob({ lane: "task:d", type: "worker_task", payload: {}, run_id: "r4", max_attempts: 2 });
-    await claimJob(job.id, "boot-1");            // attempts = 1
-    await reclaimOrInterrupt(job.id, { force: true }); // back to pending
-    await claimJob(job.id, "boot-2");            // attempts = 2
-    const final = await reclaimOrInterrupt(job.id, { force: true });
-
-    expect(final!.status).toBe("interrupted");
-    expect(final!.error).toContain("Max attempts");
-  });
-});

package/test/harness-barrel.test.ts

@@ -1,64 +0,0 @@
-/**
- * `harness/` pasó de tener implementación propia a ser un barrel.
- *
- * Hasta 0.1.5 el módulo traía sus propias copias de `db-helpers`, `boot-id`,
- * `reconcile`, `collections`, `run-store`, `run-epoch` y `proof-packet`, en
- * paralelo con las de `storage/` y `agent/`. Dos almacenes de jobs sobre las
- * mismas colecciones de HiveDB son una sola cosa con dos estados posibles.
- *
- * Lo que este test protege no es el comportamiento (eso lo cubren
- * job-store/durable-queue/run-store.test.ts) sino el contrato del subpath
- * `@johpaz/hive-sdk/harness`: que siga exportando los mismos nombres y que
- * apunten a la implementación única.
- */
-
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, test, expect } from "bun:test";
-import * as harness from "../packages/core/src/harness/index.ts";
-import { createJob } from "../packages/core/src/gateway/job-store.ts";
-import { createRun } from "../packages/core/src/agent/run-store.ts";
-import { col } from "../packages/core/src/storage/hive.ts";
-
-describe("subpath @johpaz/hive-sdk/harness", () => {
-  test("sigue exportando la superficie que tenía", () => {
-    for (const name of [
-      "createJob",
-      "getJob",
-      "registerExecutor",
-      "getDurableQueue",
-      "initDurableQueue",
-      "DurableLaneQueue",
-      "createRun",
-      "checkpoint",
-      "completeRun",
-      "failRun",
-      "interruptRun",
-      "reclaimRun",
-      "getRun",
-      "buildRunEpoch",
-      "buildProofPacket",
-      "verifyGoal",
-      "getBootId",
-      "resetBootId",
-      "reconcileOnBoot",
-      "ensureHarnessIndexes",
-      "col",
-      "nextId",
-      "updateDoc",
-      "findByAny",
-      "toIndexable",
-      "fromIndexable",
-      "NO_PARENT",
-    ]) {
-      expect(harness[name as keyof typeof harness], `falta el export ${name}`).toBeDefined();
-    }
-  });
-
-  test("re-exporta la misma función, no una copia", () => {
-    // Si esto falla es que harness/ volvió a tener implementación propia.
-    expect(harness.createJob).toBe(createJob);
-    expect(harness.createRun).toBe(createRun);
-    expect(harness.col).toBe(col);
-  });
-});