@johpaz/hive-sdk 0.1.6 → 0.2.0

package/test/retired-capabilities-pruned.test.ts

@@ -1,192 +0,0 @@
-/**
- * Seeding is put-in-place with natural ids, so dropping a tool from SEED_DATA
- * or deleting a bundled SKILL.md does NOT remove the row an older install
- * already wrote — and a stale row stays discoverable through search_knowledge
- * while its executor no longer exists. `pruneRetired()` in seed.ts closes that
- * gap; this test simulates the upgrade path it exists for.
- *
- * Uses HIVE_DB_PATH=":memory:".
- */
-
-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 { seedAllData } from "../packages/core/src/storage/seed";
-import { col } from "../packages/core/src/storage/hive";
-import { createAllTools } from "../packages/core/src/tools/index";
-import { syncToolsToIndex, syncSkillsToIndex } from "../packages/core/src/agent/context-compiler";
-import { searchCapabilities } from "../packages/core/src/agent/capability-search";
-import type { AgentDoc, ToolDoc, SkillDoc } from "../packages/core/src/storage/collections";
-
-const RETIRED_TOOL = "task_delegate_code";
-const RETIRED_SKILL = "code_delegator";
-/** Projects/DAG: withdrawn when this instance stopped managing projects. */
-const RETIRED_PROJECT_TOOLS = ["project_create", "project_status", "task_create", "task_complete"];
-const RETIRED_CANVAS_TOOLS = [
-  "canvas_render",
-  "canvas_ask",
-  "canvas_confirm",
-  "canvas_show_card",
-  "canvas_show_progress",
-  "canvas_show_list",
-  "canvas_clear",
-];
-const RETIRED_CANVAS_SKILLS = ["canvas_report", "canvas_dashboard", "canvas_interact"];
-const RETIRED_CANVAS_AGENT = "canvas_presenter";
-
-beforeEach(async () => {
-  closeHiveDb();
-  await ensureHiveDb();
-});
-
-afterEach(() => {
-  closeHiveDb();
-});
-
-/** Recreates what a pre-upgrade install has sitting in its DB. */
-async function writeLegacyRows(): Promise<void> {
-  const now = Date.now();
-  const toolsCol = await col<ToolDoc>("tools");
-  for (const id of [RETIRED_TOOL, ...RETIRED_CANVAS_TOOLS]) {
-    await toolsCol.put(id, {
-      id,
-      name: id,
-      description: `Legacy capability ${id}`,
-      category: id.startsWith("canvas_") ? "canvas" : "agents",
-      enabled: true,
-      active: true,
-      created_at: now,
-      updated_at: now,
-    });
-  }
-
-  const skillsCol = await col<SkillDoc>("skills");
-  for (const id of [RETIRED_SKILL, ...RETIRED_CANVAS_SKILLS]) {
-    await skillsCol.put(id, {
-      id,
-      name: id,
-      description: `Legacy skill ${id}`,
-      version: "1.0.0",
-      author: "Hive Team",
-      icon: "🧹",
-      category: id.startsWith("canvas_") ? "canvas" : "agents",
-      permissions: "[]",
-      dependencies: "[]",
-      tools: id.startsWith("canvas_") ? "canvas_render" : "task_delegate_code",
-      triggers: id,
-      preferred_agents: "[]",
-      body: `# ${id}`,
-      version_num: 1,
-      active: true,
-      created_at: now,
-      updated_at: now,
-    });
-  }
-
-  const agentsCol = await col<AgentDoc>("agents");
-  const template = (await agentsCol.get("workspace_file_operator"))!.doc;
-  await agentsCol.put(RETIRED_CANVAS_AGENT, {
-    ...template,
-    id: RETIRED_CANVAS_AGENT,
-    name: "Presentador Canvas",
-    source: "catalog",
-  });
-}
-
-describe("retired Code Bridge capabilities", () => {
-  test("a fresh seed never creates them", async () => {
-    expect(await (await col<ToolDoc>("tools")).get(RETIRED_TOOL)).toBeUndefined();
-    expect(await (await col<SkillDoc>("skills")).get(RETIRED_SKILL)).toBeUndefined();
-    for (const id of RETIRED_CANVAS_TOOLS) {
-      expect(await (await col<ToolDoc>("tools")).get(id)).toBeUndefined();
-    }
-    for (const id of RETIRED_CANVAS_SKILLS) {
-      expect(await (await col<SkillDoc>("skills")).get(id)).toBeUndefined();
-    }
-    expect(await (await col<AgentDoc>("agents")).get(RETIRED_CANVAS_AGENT)).toBeUndefined();
-  });
-
-  test("rows left by an older install are deleted on the next boot", async () => {
-    await writeLegacyRows();
-    expect(await (await col<ToolDoc>("tools")).get(RETIRED_TOOL)).toBeTruthy();
-    expect(await (await col<SkillDoc>("skills")).get(RETIRED_SKILL)).toBeTruthy();
-    expect(await (await col<AgentDoc>("agents")).get(RETIRED_CANVAS_AGENT)).toBeTruthy();
-
-    await seedAllData(); // what ensureHiveDb() runs on every boot
-
-    expect(await (await col<ToolDoc>("tools")).get(RETIRED_TOOL)).toBeUndefined();
-    expect(await (await col<SkillDoc>("skills")).get(RETIRED_SKILL)).toBeUndefined();
-    for (const id of RETIRED_CANVAS_TOOLS) {
-      expect(await (await col<ToolDoc>("tools")).get(id)).toBeUndefined();
-    }
-    for (const id of RETIRED_CANVAS_SKILLS) {
-      expect(await (await col<SkillDoc>("skills")).get(id)).toBeUndefined();
-    }
-    expect(await (await col<AgentDoc>("agents")).get(RETIRED_CANVAS_AGENT)).toBeUndefined();
-  });
-
-  test("pruning leaves the surviving catalog intact", async () => {
-    await writeLegacyRows();
-    await seedAllData();
-
-    const tools = (await (await col<ToolDoc>("tools")).scan({})).map((e) => e.doc.name);
-    expect(tools).toContain("task_delegate");
-    expect(tools).toContain("task_status");
-
-    const skills = (await (await col<SkillDoc>("skills")).scan({})).map((e) => e.doc.name);
-    expect(skills).toContain("task_orchestrator");
-    expect(skills).toContain("agent_spawner");
-  });
-
-  test("project/DAG rows from an older install are deleted too", async () => {
-    const toolsCol = await col<ToolDoc>("tools");
-    const now = Date.now();
-    for (const id of RETIRED_PROJECT_TOOLS) {
-      await toolsCol.put(id, {
-        id, name: id, description: `Legacy project tool ${id}`, category: "projects",
-        enabled: true, active: true, created_at: now, updated_at: now,
-      });
-    }
-    for (const id of RETIRED_PROJECT_TOOLS) expect(await toolsCol.get(id)).toBeTruthy();
-
-    await seedAllData();
-
-    for (const id of RETIRED_PROJECT_TOOLS) expect(await toolsCol.get(id)).toBeUndefined();
-  });
-
-  test("no executor is registered for the retired tool", () => {
-    const names = createAllTools({ tools: {} } as never).map((t) => t.name);
-    expect(names).not.toContain(RETIRED_TOOL);
-    for (const id of RETIRED_PROJECT_TOOLS) expect(names).not.toContain(id);
-    for (const id of RETIRED_CANVAS_TOOLS) expect(names).not.toContain(id);
-    expect(names).toContain("task_delegate");
-    expect(names).toContain("a2ui_create_surface");
-  });
-
-  // Deleting the row is only half the job: search_knowledge queries the
-  // capability index, so an entry indexed before the upgrade must not survive
-  // the re-sync — otherwise the agent still discovers a tool with no executor.
-  test("search_knowledge can no longer discover them after the upgrade", async () => {
-    await writeLegacyRows();
-    await syncToolsToIndex();
-    await syncSkillsToIndex();
-
-    const stale = await searchCapabilities("code bridge subagente CLI", { types: ["tool", "skill"], k: 25 });
-    expect(stale.map((hit) => hit.rawId)).toContain(RETIRED_TOOL);
-
-    await seedAllData();   // prunes the rows
-    await syncToolsToIndex(); // full replace per type
-    await syncSkillsToIndex();
-
-    const fresh = await searchCapabilities("code bridge subagente CLI", { types: ["tool", "skill"], k: 25 });
-    const ids = fresh.map((hit) => hit.rawId);
-    expect(ids).not.toContain(RETIRED_TOOL);
-    expect(ids).not.toContain(RETIRED_SKILL);
-
-    // The index is still populated — the replace didn't just empty it.
-    const alive = await searchCapabilities("delegar tarea agente", { types: ["tool"], k: 25 });
-    expect(alive.map((hit) => hit.rawId)).toContain("task_delegate");
-  });
-});

package/test/run-store.test.ts

@@ -1,355 +0,0 @@
-/**
- * Tests for agent/run-store.ts — AgentRun lifecycle, checkpoint, lease.
- * Uses HIVE_DB_PATH=":memory:" so no state persists between runs.
- */
-
-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 { col } from "../packages/core/src/storage/hive";
-import type { AgentRunDoc } from "../packages/core/src/storage/collections";
-import {
-  createRun,
-  checkpoint,
-  completeRun,
-  failRun,
-  interruptRun,
-  getRun,
-  findRunsByStatus,
-  findExpiredRuns,
-  deserializeCheckpoint,
-  type RunCheckpointState,
-} from "../packages/core/src/agent/run-store";
-import { getBootId, resetBootId } from "../packages/core/src/storage/boot-id";
-
-beforeEach(async () => {
-  closeHiveDb();
-  resetBootId();
-  await ensureHiveDb();
-});
-
-afterEach(() => {
-  closeHiveDb();
-});
-
-describe("run-store: createRun", () => {
-  test("creates a running run with correct defaults", async () => {
-    const run = await createRun({
-      thread_id: "thread1",
-      agent_id: "agent1",
-      user_id: "user1",
-      channel: "webchat",
-      kind: "chat",
-      max_iterations: 10,
-    });
-
-    expect(run.thread_id).toBe("thread1");
-    expect(run.agent_id).toBe("agent1");
-    expect(run.kind).toBe("chat");
-    expect(run.status).toBe("running");
-    expect(run.iterations_used).toBe(0);
-    expect(run.max_iterations).toBe(10);
-    expect(run.max_turns).toBeNull();
-    expect(run.max_tokens).toBeNull();
-    expect(run.goal).toBeNull();
-    expect(run.resume_policy).toBe("resume");
-    expect(run.error).toBeNull();
-    expect(run.lease_expires_at).toBeGreaterThan(Date.now());
-    expect(run.boot_id).toBe(getBootId());
-  });
-
-  test("creates with goal and budget overrides", async () => {
-    const run = await createRun({
-      thread_id: "thread1",
-      agent_id: "agent1",
-      user_id: "user1",
-      channel: null,
-      kind: "goal",
-      max_iterations: 50,
-      max_turns: 5,
-      max_tokens: 100_000,
-      goal: "build feature X",
-      goal_check_tool: "verify_feature",
-      resume_policy: "discard",
-    });
-
-    expect(run.kind).toBe("goal");
-    expect(run.max_turns).toBe(5);
-    expect(run.max_tokens).toBe(100_000);
-    expect(run.goal).toBe("build feature X");
-    expect(run.goal_check_tool).toBe("verify_feature");
-    expect(run.resume_policy).toBe("discard");
-  });
-});
-
-describe("run-store: checkpoint", () => {
-  test("saves and deserializes checkpoint state", async () => {
-    const run = await createRun({
-      thread_id: "thread1",
-      agent_id: "agent1",
-      user_id: "user1",
-      channel: "webchat",
-      kind: "chat",
-      max_iterations: 10,
-    });
-
-    const state: RunCheckpointState = {
-      version: 1,
-      messages: [
-        { role: "system", content: "You are an agent" },
-        { role: "user", content: "Hello" },
-        { role: "assistant", content: "Hi there" },
-      ],
-      iterations: 3,
-      totalInputTokens: 500,
-      totalOutputTokens: 200,
-      lastToolSignature: "",
-      consecutiveRepeat: 0,
-      idleIterations: 0,
-      injectedToolNames: ["search_knowledge"],
-      systemPromptSkillSections: ["## Skill: coding"],
-    };
-
-    await checkpoint(run.id, state);
-
-    const saved = await getRun(run.id);
-    expect(saved).not.toBeNull();
-    expect(saved!.iterations_used).toBe(3);
-    expect(saved!.tokens_used).toBe(700);
-
-    const deserialized = deserializeCheckpoint(saved!);
-    expect(deserialized).not.toBeNull();
-    expect(deserialized!.iterations).toBe(3);
-    expect(deserialized!.totalInputTokens).toBe(500);
-    expect(deserialized!.totalOutputTokens).toBe(200);
-    expect(deserialized!.messages.length).toBe(3);
-    expect(deserialized!.injectedToolNames).toEqual(["search_knowledge"]);
-  });
-
-  test("normalizes a stray trailing system message (pre-source checkpoint) to a wrapped user turn", async () => {
-    const run = await createRun({
-      thread_id: "thread-stray-system",
-      agent_id: "agent1",
-      user_id: "user1",
-      channel: "webchat",
-      kind: "chat",
-      max_iterations: 10,
-    });
-
-    // Checkpoints written before `source` existed could carry a second
-    // system message — the compaction summary or a delegation notice —
-    // after the real system prompt at index 0.
-    const state: RunCheckpointState = {
-      version: 1,
-      messages: [
-        { role: "system", content: "You are an agent" },
-        { role: "user", content: "Hello" },
-        { role: "system", content: "[Conversation Summary]: resumen previo" },
-      ],
-      iterations: 1,
-      totalInputTokens: 10,
-      totalOutputTokens: 10,
-      lastToolSignature: "",
-      consecutiveRepeat: 0,
-      idleIterations: 0,
-      injectedToolNames: [],
-      systemPromptSkillSections: [],
-    };
-
-    await checkpoint(run.id, state);
-    const saved = await getRun(run.id);
-    const deserialized = deserializeCheckpoint(saved!);
-
-    expect(deserialized).not.toBeNull();
-    // index 0 stays the real system prompt.
-    expect(deserialized!.messages[0].role).toBe("system");
-    expect(deserialized!.messages[0].content).toBe("You are an agent");
-    // the stray one is rewritten as a wrapped user turn, not dropped.
-    expect(deserialized!.messages[2].role).toBe("user");
-    expect(deserialized!.messages[2].content).toContain('<hive:internal_event source="legacy_internal">');
-    expect(deserialized!.messages[2].content).toContain("resumen previo");
-    // exactly one system message survives.
-    expect(deserialized!.messages.filter((m) => m.role === "system")).toHaveLength(1);
-  });
-
-  test("truncates large tool results to stay under MAX_STATE_BYTES", async () => {
-    const run = await createRun({
-      thread_id: "thread1",
-      agent_id: "agent1",
-      user_id: "user1",
-      channel: "webchat",
-      kind: "chat",
-      max_iterations: 10,
-    });
-
-    const bigContent = "x".repeat(200_000);
-    const messages = [];
-    for (let i = 0; i < 20; i++) {
-      messages.push({ role: "user" as const, content: `msg ${i}` });
-      messages.push({ role: "tool" as const, content: bigContent, tool_call_id: `tc_${i}` });
-    }
-    const state: RunCheckpointState = {
-      version: 1,
-      messages,
-      iterations: 5,
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      lastToolSignature: "",
-      consecutiveRepeat: 0,
-      idleIterations: 0,
-      injectedToolNames: [],
-      systemPromptSkillSections: [],
-    };
-
-    await checkpoint(run.id, state);
-
-    const saved = await getRun(run.id);
-    expect(saved!.state_bytes).toBeLessThanOrEqual(1_500_000);
-  });
-
-  test("saves pending_tool_calls_json", async () => {
-    const run = await createRun({
-      thread_id: "thread1",
-      agent_id: "agent1",
-      user_id: "user1",
-      channel: "webchat",
-      kind: "chat",
-      max_iterations: 10,
-    });
-
-    const state: RunCheckpointState = {
-      version: 1,
-      messages: [{ role: "user", content: "test" }],
-      iterations: 2,
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      lastToolSignature: "",
-      consecutiveRepeat: 0,
-      idleIterations: 0,
-      injectedToolNames: [],
-      systemPromptSkillSections: [],
-    };
-
-    const pending = [
-      { id: "tc1", function: { name: "memory_write", arguments: "{}" } },
-    ];
-
-    await checkpoint(run.id, state, pending);
-
-    const saved = await getRun(run.id);
-    expect(saved!.pending_tool_calls_json).not.toBeNull();
-    const parsed = JSON.parse(saved!.pending_tool_calls_json!);
-    expect(parsed[0].function.name).toBe("memory_write");
-  });
-});
-
-describe("run-store: lifecycle transitions", () => {
-  test("completeRun sets status to completed and clears checkpoint", async () => {
-    const run = await createRun({
-      thread_id: "thread1",
-      agent_id: "agent1",
-      user_id: "user1",
-      channel: "webchat",
-      kind: "chat",
-      max_iterations: 10,
-    });
-
-    await completeRun(run.id);
-
-    const saved = await getRun(run.id);
-    expect(saved!.status).toBe("completed");
-    expect(saved!.state_json).toBe("");
-    expect(saved!.state_bytes).toBe(0);
-    expect(saved!.pending_tool_calls_json).toBeNull();
-    expect(saved!.finished_at).not.toBeNull();
-  });
-
-  test("failRun sets error message", async () => {
-    const run = await createRun({
-      thread_id: "thread1",
-      agent_id: "agent1",
-      user_id: "user1",
-      channel: "webchat",
-      kind: "worker",
-      max_iterations: 10,
-    });
-
-    await failRun(run.id, "Something went wrong");
-
-    const saved = await getRun(run.id);
-    expect(saved!.status).toBe("failed");
-    expect(saved!.error).toBe("Something went wrong");
-  });
-
-  test("interruptRun sets interrupted status", async () => {
-    const run = await createRun({
-      thread_id: "thread1",
-      agent_id: "agent1",
-      user_id: "user1",
-      channel: "webchat",
-      kind: "chat",
-      max_iterations: 10,
-    });
-
-    await interruptRun(run.id, "Process restarted");
-
-    const saved = await getRun(run.id);
-    expect(saved!.status).toBe("interrupted");
-    expect(saved!.error).toContain("Process restarted");
-  });
-});
-
-describe("run-store: lease expiry", () => {
-  test("findExpiredRuns returns runs with expired lease", async () => {
-    const run = await createRun({
-      thread_id: "thread1",
-      agent_id: "agent1",
-      user_id: "user1",
-      channel: "webchat",
-      kind: "chat",
-      max_iterations: 10,
-    });
-
-    // Force lease expiry by setting lease_expires_at to past
-    const c = await col<AgentRunDoc>("agentRuns");
-    await c.put(run.id, { ...run, lease_expires_at: Date.now() - 1000 }, { expectedVersion: 1 });
-
-    const expired = await findExpiredRuns();
-    expect(expired.length).toBe(1);
-    expect(expired[0].id).toBe(run.id);
-  });
-
-  test("findExpiredRuns skips runs with active lease", async () => {
-    await createRun({
-      thread_id: "thread1",
-      agent_id: "agent1",
-      user_id: "user1",
-      channel: "webchat",
-      kind: "chat",
-      max_iterations: 10,
-    });
-
-    const expired = await findExpiredRuns();
-    expect(expired.length).toBe(0);
-  });
-});
-
-describe("run-store: findRunsByStatus", () => {
-  test("finds runs by status index", async () => {
-    const run1 = await createRun({ thread_id: "t1", agent_id: "a1", user_id: "u1", channel: null, kind: "chat", max_iterations: 10 });
-    const run2 = await createRun({ thread_id: "t2", agent_id: "a2", user_id: "u1", channel: null, kind: "worker", max_iterations: 10 });
-
-    await completeRun(run1.id);
-    await failRun(run2.id, "err");
-
-    const completed = await findRunsByStatus("completed");
-    const failed = await findRunsByStatus("failed");
-    const running = await findRunsByStatus("running");
-
-    expect(completed.length).toBe(1);
-    expect(failed.length).toBe(1);
-    expect(running.length).toBe(0);
-  });
-});

package/test/scratchpad.test.ts

@@ -1,74 +0,0 @@
-/**
- * Scratchpad — integration tests
- *
- * Covers the first table migrated off SQLite onto a HiveDB document
- * collection: packages/core/src/agent/conversation-store.ts's scratchpad
- * functions on top of @johpaz/hive-db.
- *
- * Uses an in-memory index (HIVE_DB_PATH=":memory:") so no state
- * touches ~/.hive.
- */
-
-process.env.HIVE_DB_PATH = ":memory:";
-
-import { describe, test, expect, afterAll } from "bun:test";
-import {
-  saveScratchpadNote,
-  getScratchpad,
-  deleteScratchpadNote,
-  listAllScratchpadNotes,
-} from "../packages/core/src/agent/conversation-store";
-import { closeHiveDb } from "../packages/core/src/storage/hivedb";
-
-afterAll(() => {
-  closeHiveDb();
-});
-
-describe("scratchpad (HiveDB collection)", () => {
-  test("save then get round-trips a note", async () => {
-    await saveScratchpadNote("t1", "greeting", "hola mundo", "agent");
-    const notes = await getScratchpad("t1");
-    expect(notes).toEqual([{ key: "greeting", value: "hola mundo" }]);
-  });
-
-  test("saving the same key again updates the value, not appends", async () => {
-    await saveScratchpadNote("t2", "k", "v1");
-    await saveScratchpadNote("t2", "k", "v2");
-    const notes = await getScratchpad("t2");
-    expect(notes).toEqual([{ key: "k", value: "v2" }]);
-  });
-
-  test("notes are scoped per thread", async () => {
-    await saveScratchpadNote("t3", "a", "1");
-    await saveScratchpadNote("t4", "b", "2");
-    expect(await getScratchpad("t3")).toEqual([{ key: "a", value: "1" }]);
-    expect(await getScratchpad("t4")).toEqual([{ key: "b", value: "2" }]);
-  });
-
-  test("most recently updated note comes first", async () => {
-    await saveScratchpadNote("t5", "first", "1");
-    await saveScratchpadNote("t5", "second", "2");
-    const notes = await getScratchpad("t5");
-    expect(notes.map((n) => n.key)).toEqual(["second", "first"]);
-  });
-
-  test("delete removes only the targeted note", async () => {
-    await saveScratchpadNote("t6", "keep", "x");
-    await saveScratchpadNote("t6", "gone", "y");
-    await deleteScratchpadNote("t6", "gone");
-    expect(await getScratchpad("t6")).toEqual([{ key: "keep", value: "x" }]);
-  });
-
-  test("unknown thread returns an empty list", async () => {
-    expect(await getScratchpad("does-not-exist")).toEqual([]);
-  });
-
-  test("listAllScratchpadNotes spans every thread, most recent first, respecting limit", async () => {
-    await saveScratchpadNote("global-a", "k", "v");
-    await saveScratchpadNote("global-b", "k", "v");
-    const all = await listAllScratchpadNotes(1);
-    expect(all.length).toBe(1);
-    expect(all[0].thread_id).toBe("global-b");
-    expect(all[0].id).toBe("global-b:k");
-  });
-});