@johpaz/hive-sdk 0.1.5 → 0.2.0

package/scripts/generate-skill-bundle.ts

@@ -1,108 +0,0 @@
-/**
- * generate-bundle.ts
- * Scans all SKILL.md files from src/bundled/ and generates
- * src/bundled-data.generated.ts with all skill data inlined as TypeScript.
- * This file is then bundled into dist/hive.js so skills load without FS access.
- *
- * Usage: bun scripts/generate-skill-bundle.ts
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { YAML } from "bun";
-
-const BUNDLED_DIR = path.join(import.meta.dir, "../packages/core/src/skills/bundled");
-const OUTPUT_FILE = path.join(import.meta.dir, "../packages/core/src/skills/bundled-data.generated.ts");
-
-interface SkillEntry {
-  name: string;
-  description: string;
-  category: string;
-  version: string;
-  tools: string[];
-  triggers: string[];
-  body: string;
-}
-
-function parseFrontmatter(content: string): { frontmatter: Record<string, unknown>; body: string } {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!match) return { frontmatter: {}, body: content };
-  try {
-    const frontmatter = YAML.parse(match[1]!) as Record<string, unknown>;
-    return { frontmatter, body: match[2]! };
-  } catch {
-    return { frontmatter: {}, body: content };
-  }
-}
-
-function scanDir(dir: string): SkillEntry[] {
-  const skills: SkillEntry[] = [];
-
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const entryPath = path.join(dir, entry.name);
-    const skillMdPath = path.join(entryPath, "SKILL.md");
-
-    if (fs.existsSync(skillMdPath)) {
-      const content = fs.readFileSync(skillMdPath, "utf-8");
-      const { frontmatter, body } = parseFrontmatter(content);
-
-      skills.push({
-        name: (frontmatter.name as string) ?? entry.name,
-        description: (frontmatter.description as string) ?? "",
-        category: (frontmatter.category as string) ?? "general",
-        version: String(frontmatter.version ?? "1.0.0"),
-        tools: (frontmatter.tools as string[]) ?? [],
-        triggers: (frontmatter.triggers as string[]) ?? [],
-        body,
-      });
-    } else {
-      // Category directory — recurse one level
-      skills.push(...scanDir(entryPath));
-    }
-  }
-
-  return skills;
-}
-
-const skills = scanDir(BUNDLED_DIR);
-
-const lines: string[] = [
-  "// AUTO-GENERATED by scripts/generate-skill-bundle.ts",
-  "// Do NOT edit manually — run `bun scripts/generate-skill-bundle.ts` to regenerate",
-  "",
-  "export interface BundledSkillEntry {",
-  "  name: string;",
-  "  description: string;",
-  "  category: string;",
-  "  version: string;",
-  "  tools: string[];",
-  "  triggers: string[];",
-  "  body: string;",
-  "}",
-  "",
-  `export const BUNDLED_SKILLS_DATA: BundledSkillEntry[] = [`,
-];
-
-for (const skill of skills) {
-  // Escape backticks and template literal delimiters in body content
-  const escapedBody = skill.body.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
-  const escapedDescription = skill.description.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
-
-  lines.push(`  {`);
-  lines.push(`    name: ${JSON.stringify(skill.name)},`);
-  lines.push(`    description: \`${escapedDescription}\`,`);
-  lines.push(`    category: ${JSON.stringify(skill.category)},`);
-  lines.push(`    version: ${JSON.stringify(skill.version)},`);
-  lines.push(`    tools: ${JSON.stringify(skill.tools)},`);
-  lines.push(`    triggers: ${JSON.stringify(skill.triggers)},`);
-  lines.push(`    body: \`${escapedBody}\`,`);
-  lines.push(`  },`);
-}
-
-lines.push(`];`);
-lines.push(``);
-
-fs.writeFileSync(OUTPUT_FILE, lines.join("\n"), "utf-8");
-
-console.info(`[generate-bundle] ✅ Generated ${skills.length} skills → ${path.relative(process.cwd(), OUTPUT_FILE)}`);

package/test/agent-loop-terminal-synthesis.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  AgentSynthesisError,
-  synthesizeFinalResponse,
-} from "../packages/core/src/agent/agent-loop";
-
-describe("agent loop terminal synthesis", () => {
-  test("retries once and returns the real model response", async () => {
-    let calls = 0;
-    const result = await synthesizeFinalResponse(async () => {
-      calls++;
-      if (calls === 1) throw new Error("temporary provider failure");
-      return "Estado real de la tarea";
-    });
-
-    expect(result).toBe("Estado real de la tarea");
-    expect(calls).toBe(2);
-  });
-
-  test("fails closed after two empty or failed responses", async () => {
-    let calls = 0;
-    const operation = synthesizeFinalResponse(async () => {
-      calls++;
-      if (calls === 1) return "   ";
-      throw new Error("provider unavailable");
-    });
-
-    await expect(operation).rejects.toBeInstanceOf(AgentSynthesisError);
-    await expect(operation).rejects.toThrow("provider unavailable");
-    expect(calls).toBe(2);
-  });
-});

package/test/catalog-agents-stay-enabled.test.ts

@@ -1,117 +0,0 @@
-/**
- * A catalog persona is a capability of the whole hive, not a disposable
- * worker: nothing automatic may switch one off. Disabling is the user's call,
- * from the Agents UI (PUT /api/agents/:id). 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 { col } from "../packages/core/src/storage/hive";
-import type { AgentDoc, AgentProposalDoc } from "../packages/core/src/storage/collections";
-import { runCurator } from "../packages/core/src/agent/curator";
-import { agentArchiveTool } from "../packages/core/src/tools/agents";
-import { CATALOG_AGENT_IDS } from "../packages/core/src/agent/agent-catalog";
-
-const VICTIM = "workspace_file_operator";
-
-beforeEach(async () => {
-  closeHiveDb();
-  await ensureHiveDb();
-});
-
-afterEach(() => {
-  closeHiveDb();
-});
-
-async function agent(id: string): Promise<AgentDoc> {
-  const entry = await (await col<AgentDoc>("agents")).get(id);
-  if (!entry) throw new Error(`agent not found: ${id}`);
-  return entry.doc;
-}
-
-async function setCounters(id: string, helpful: number, harmful: number): Promise<void> {
-  const agentsCol = await col<AgentDoc>("agents");
-  const entry = (await agentsCol.get(id))!;
-  await agentsCol.put(id, { ...entry.doc, helpful_count: helpful, harmful_count: harmful }, { expectedVersion: entry.version });
-}
-
-describe("curator", () => {
-  test("never disables a catalog agent, however bad its ACE counters are", async () => {
-    await setCounters(VICTIM, 0, 25);
-
-    await runCurator();
-
-    expect((await agent(VICTIM)).enabled).toBe(true);
-  });
-
-  test("raises a reviewable proposal instead of applying the change", async () => {
-    await setCounters(VICTIM, 0, 5);
-
-    await runCurator();
-
-    const proposals = (await (await col<AgentProposalDoc>("agentProposals")).findBy("agent_id", VICTIM)).map(e => e.doc);
-    expect(proposals).toHaveLength(1);
-    expect(proposals[0].type).toBe("disable_agent");
-    expect(proposals[0].status).toBe("proposed");
-  });
-
-  test("does not archive catalog agents that were never used", async () => {
-    // Seeded with lastTraceAt=null, which the inactivity cutoff reads as epoch 0
-    expect((await agent(VICTIM)).lastTraceAt).toBeNull();
-
-    await runCurator();
-
-    for (const id of CATALOG_AGENT_IDS) {
-      expect((await agent(id)).status).not.toBe("archived");
-    }
-  });
-
-  test("repairs a catalog agent archived by an older release on boot", async () => {
-    const agentsCol = await col<AgentDoc>("agents");
-    const existing = (await agentsCol.get(VICTIM))!;
-    await agentsCol.put(
-      VICTIM,
-      { ...existing.doc, status: "archived" },
-      { expectedVersion: existing.version },
-    );
-
-    await ensureHiveDb();
-
-    expect((await agent(VICTIM)).status).toBe("idle");
-  });
-
-  test("does not archive an inactive worker automatically", async () => {
-    const agentsCol = await col<AgentDoc>("agents");
-    const stale = { ...(await agent(VICTIM)), id: "stale-worker", source: "user" as const, lastTraceAt: 1 };
-    await agentsCol.put(stale.id, stale);
-
-    await runCurator();
-
-    expect((await agent("stale-worker")).status).not.toBe("archived");
-    expect((await agent("stale-worker")).enabled).toBe(true);
-  });
-});
-
-describe("agent_archive tool", () => {
-  test("refuses to archive a catalog agent", async () => {
-    const result = await agentArchiveTool.execute({ agentId: VICTIM }) as { ok: boolean; error?: string };
-
-    expect(result.ok).toBe(false);
-    expect(result.error).toContain("catalog agent");
-    expect((await agent(VICTIM)).enabled).toBe(true);
-  });
-
-  test("still archives a worker created by the coordinator", async () => {
-    const agentsCol = await col<AgentDoc>("agents");
-    const worker = { ...(await agent(VICTIM)), id: "spawned-worker", source: "user" as const };
-    await agentsCol.put(worker.id, worker);
-
-    const result = await agentArchiveTool.execute({ agentId: "spawned-worker" }) as { ok: boolean };
-
-    expect(result.ok).toBe(true);
-    expect((await agent("spawned-worker")).enabled).toBe(false);
-  });
-});

package/test/causal-events.test.ts

@@ -1,117 +0,0 @@
-/**
- * Track B feasibility proof: HiveDB's subscribe()/events() (wrapped by
- * watchCausalEvents()) actually works for hive's use case — forward
- * delivery, pattern filtering, and clean shutdown — and explicitly proves
- * the "no historical replay" constraint documented in causal-events.ts
- * (subscribe()/events() are a pure in-process pub/sub, not a durable read
- * of the log — see hiveBD's reactive.rs).
- */
-
-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 { watchCausalEvents } from "../packages/core/src/storage/causal-events";
-import type { CausalEvent } from "../packages/core/src/storage/causal-events";
-
-beforeEach(async () => {
-  closeHiveDb();
-  resetBootId();
-  await ensureHiveDb();
-});
-
-afterEach(() => {
-  closeHiveDb();
-});
-
-describe("causal-events: watchCausalEvents()", () => {
-  test("delivers only events matching the pattern, forward, in order", async () => {
-    const stream = await watchCausalEvents({ agentId: "agent-x" });
-    const db = await getHiveDb();
-
-    await db.append({
-      agentId: "agent-x",
-      streamId: "s1",
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "agent-x", intent: "one" }),
-    });
-    await db.append({
-      agentId: "agent-other",
-      streamId: "s2",
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "agent-other", intent: "should be filtered out" }),
-    });
-    await db.append({
-      agentId: "agent-x",
-      streamId: "s1",
-      kind: "StateTransition",
-      payload: JSON.stringify({ description: "three" }),
-    });
-
-    const received: CausalEvent[] = [];
-    const iterator = stream[Symbol.asyncIterator]();
-    received.push((await iterator.next()).value!);
-    received.push((await iterator.next()).value!);
-    stream.close();
-
-    expect(received.length).toBe(2);
-    expect(received.every((e) => e.agentId === "agent-x")).toBe(true);
-    expect(received.map((e) => e.kindTag)).toEqual(["IntentLogged", "StateTransition"]);
-  });
-
-  test("has no historical replay: events appended before subscribing are never delivered", async () => {
-    const db = await getHiveDb();
-    await db.append({
-      agentId: "agent-y",
-      streamId: "s1",
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "agent-y", intent: "pre-existing, must not be delivered" }),
-    });
-
-    // Subscribe AFTER the append above.
-    const stream = await watchCausalEvents({ agentId: "agent-y" });
-    const iterator = stream[Symbol.asyncIterator]();
-
-    const raceResult = await Promise.race([
-      iterator.next().then((r) => ({ type: "event" as const, value: r.value })),
-      new Promise<{ type: "timeout" }>((resolve) => setTimeout(() => resolve({ type: "timeout" }), 200)),
-    ]);
-    expect(raceResult.type).toBe("timeout");
-
-    // Prove the stream itself still works for a genuinely new event —
-    // distinguishes "no replay" from "the stream is just broken".
-    await db.append({
-      agentId: "agent-y",
-      streamId: "s1",
-      kind: "StateTransition",
-      payload: JSON.stringify({ description: "post-subscribe, must be delivered" }),
-    });
-    const { value: event } = await iterator.next();
-    expect(event?.kindTag).toBe("StateTransition");
-
-    stream.close();
-  });
-
-  test("close() ends the for-await loop cleanly and doesn't block a subsequent closeHiveDb()", async () => {
-    const stream = await watchCausalEvents({ agentId: "agent-z" });
-    const db = await getHiveDb();
-    await db.append({
-      agentId: "agent-z",
-      streamId: "s1",
-      kind: "IntentLogged",
-      payload: JSON.stringify({ actor: "agent-z", intent: "one" }),
-    });
-
-    const collected: CausalEvent[] = [];
-    for await (const event of stream) {
-      collected.push(event);
-      stream.close();
-    }
-
-    expect(collected.length).toBe(1);
-    // afterEach's closeHiveDb() must not hang/throw with this subscription
-    // closed-but-not-drained — implicitly verified by the test completing.
-  });
-});

package/test/compaction.test.ts

@@ -1,105 +0,0 @@
-/**
- * Pure-function tests for compaction.ts's cut-point and transcript-rendering
- * helpers — extracted so they're testable without a real LLM call
- * (compactThread() itself calls callLLM and needs network).
- */
-
-import { describe, test, expect } from "bun:test";
-import { findCompactionCutIndex, renderTranscript } from "../packages/core/src/agent/compaction";
-import type { StoredMessage } from "../packages/core/src/agent/conversation-store";
-
-function msg(partial: Partial<StoredMessage> & Pick<StoredMessage, "id" | "role" | "content">): StoredMessage {
-  return {
-    thread_id: "t",
-    channel: "webchat",
-    source: "message",
-    tool_calls_json: null,
-    tool_call_id: null,
-    reasoning_content: null,
-    content_multimodal: null,
-    token_count: 1,
-    created_at: Date.now(),
-    ...partial,
-  };
-}
-
-describe("findCompactionCutIndex", () => {
-  test("finds a clean user-turn boundary near the end of the history", () => {
-    const rows: StoredMessage[] = [
-      msg({ id: 1, role: "user", content: "a" }),
-      msg({ id: 2, role: "assistant", content: "b" }),
-      msg({ id: 3, role: "user", content: "c" }),
-      msg({ id: 4, role: "assistant", content: "d" }),
-      msg({ id: 5, role: "user", content: "e" }),
-      msg({ id: 6, role: "assistant", content: "f" }),
-      msg({ id: 7, role: "user", content: "g" }),
-    ];
-
-    // keepLastN=3 -> naive cut at index 4 (rows[4].role === "user") — already clean.
-    expect(findCompactionCutIndex(rows, 3)).toBe(4);
-  });
-
-  test("walks back to the nearest user turn when the naive cut lands on assistant", () => {
-    const rows: StoredMessage[] = [
-      msg({ id: 1, role: "user", content: "a" }),
-      msg({ id: 2, role: "user", content: "b" }), // internal event, still role:user
-      msg({ id: 3, role: "assistant", content: "c" }),
-      msg({ id: 4, role: "assistant", content: "d" }),
-    ];
-
-    // keepLastN=1 -> naive cut at index 3 (assistant) -> walk back to index 1 (user).
-    expect(findCompactionCutIndex(rows, 1)).toBe(1);
-  });
-
-  test("a tail of internal events (role:user) does not block the cut point", () => {
-    const rows: StoredMessage[] = [
-      msg({ id: 1, role: "user", content: "a" }),
-      msg({ id: 2, role: "assistant", content: "b" }),
-      msg({ id: 3, role: "user", content: "El agente completó la tarea X.", source: "task_complete" }),
-      msg({ id: 4, role: "user", content: "El agente completó la tarea Y.", source: "delegation_summary" }),
-    ];
-
-    // keepLastN=2 -> naive cut at index 2, which IS a user turn (the internal
-    // event) — before source-based framing existed, this was persisted as
-    // role:"system" and would have blocked the cut entirely.
-    expect(findCompactionCutIndex(rows, 2)).toBe(2);
-  });
-
-  test("returns 0 when no clean boundary exists (caller should skip compaction)", () => {
-    const rows: StoredMessage[] = [
-      msg({ id: 1, role: "assistant", content: "a" }),
-      msg({ id: 2, role: "assistant", content: "b" }),
-    ];
-
-    expect(findCompactionCutIndex(rows, 1)).toBe(0);
-  });
-});
-
-describe("renderTranscript", () => {
-  test("labels normal rows by role", () => {
-    const rows: StoredMessage[] = [
-      msg({ id: 1, role: "user", content: "hola" }),
-      msg({ id: 2, role: "assistant", content: "¿en qué te ayudo?" }),
-    ];
-
-    const transcript = renderTranscript(rows);
-    expect(transcript).toContain("[USER]: hola");
-    expect(transcript).toContain("[ASSISTANT]: ¿en qué te ayudo?");
-  });
-
-  test("labels internal-source rows [EVENTO INTERNO], never [USER]", () => {
-    const rows: StoredMessage[] = [
-      msg({ id: 1, role: "user", content: "El agente completó la tarea X.", source: "task_complete" }),
-    ];
-
-    const transcript = renderTranscript(rows);
-    expect(transcript).toContain("[EVENTO INTERNO]: El agente completó la tarea X.");
-    expect(transcript).not.toContain("[USER]");
-  });
-
-  test("truncates each message to maxMsgChars", () => {
-    const rows: StoredMessage[] = [msg({ id: 1, role: "user", content: "x".repeat(500) })];
-    const transcript = renderTranscript(rows, 10);
-    expect(transcript).toBe(`[USER]: ${"x".repeat(10)}`);
-  });
-});