@johpaz/hive-sdk 0.1.3 → 0.1.5

package/packages/core/src/skills/skills.test.ts

@@ -1,21 +1,62 @@
+/**
+ * El catálogo de skills bundled se genera desde los SKILL.md de `skills/bundled/`
+ * con `bun run skills:bundle`. Hasta 0.1.5 el SDK traía 44 skills copiadas a
+ * mano, 21 de las cuales invocaban tools que ya no existen (`voice_*`,
+ * `meeting_transcription`, `canvas_*`, `code_*`, `project_*`): el selector se
+ * las podía ofrecer al modelo y la ejecución moría sin ejecutor.
+ */
+
 import { describe, it, expect } from "bun:test";
 import { BUNDLED_SKILLS_DATA } from "./bundled-data.generated.ts";
+import { createAllTools } from "../tools/index.ts";
+import { loadConfig } from "../config/loader.ts";
 
 describe("Bundled skills", () => {
-  it("includes web_browser_research skill", () => {
-    const skill = BUNDLED_SKILLS_DATA.find((s) => s.name === "web_browser_research");
-    expect(skill).toBeDefined();
-    expect(skill?.category).toBe("web");
-    expect(skill?.tools).toContain("web_search");
-    expect(skill?.tools).toContain("browser_navigate");
-    expect(skill?.tools).toContain("browser_extract");
-    expect(skill?.triggers.length).toBeGreaterThan(0);
-  });
-
-  it("includes existing web and browser skills", () => {
+  it("incluye las skills web y de browser", () => {
     const names = BUNDLED_SKILLS_DATA.map((s) => s.name);
     expect(names).toContain("web_research");
     expect(names).toContain("browser_scrape");
     expect(names).toContain("browser_automate");
   });
+
+  it("no arrastra las skills retiradas", () => {
+    const names = BUNDLED_SKILLS_DATA.map((s) => s.name);
+    for (const retired of [
+      "web_browser_research",
+      "voice_input",
+      "voice_output",
+      "voice_assistant",
+      "meeting_transcription",
+      "canvas_report",
+      "canvas_dashboard",
+      "code_review",
+      "code_generate",
+      "project_planner",
+      "busqueda_fts5",
+      "ai_coder",
+      "data_analyst",
+    ]) {
+      expect(names, `la skill retirada "${retired}" volvió al bundle`).not.toContain(retired);
+    }
+  });
+
+  it("cada skill declara sólo tools que existen en el registry", async () => {
+    const available = new Set(createAllTools(await loadConfig()).map((t) => t.name));
+
+    const dangling = BUNDLED_SKILLS_DATA.flatMap((skill) =>
+      (skill.tools ?? [])
+        .filter((tool) => !available.has(tool))
+        .map((tool) => `${skill.name} → ${tool}`)
+    );
+
+    expect(dangling, `skills apuntando a tools inexistentes:\n${dangling.join("\n")}`).toEqual([]);
+  });
+
+  it("toda skill tiene nombre, descripción y categoría", () => {
+    for (const skill of BUNDLED_SKILLS_DATA) {
+      expect(skill.name, "skill sin nombre").toBeTruthy();
+      expect(skill.description, `${skill.name} sin descripción`).toBeTruthy();
+      expect(skill.category, `${skill.name} sin categoría`).toBeTruthy();
+    }
+  });
 });

package/packages/core/src/{harness → storage}/boot-id.ts

@@ -1,7 +1,10 @@
 /**
  * boot-id — a unique id generated on every process start so that durable
- * leases (harness runs / jobs) can detect which rows belong to a dead
+ * leases (agentRuns / jobQueue) can detect which rows belong to a dead
  * process after a crash/restart.
+ *
+ * The id is a short hex string; it is stable for the lifetime of the
+ * process and can be passed to {@link reconcileOnBoot}.
  */
 
 import { randomBytes } from "node:crypto";
@@ -17,4 +20,4 @@ export function getBootId(): string {
 
 export function resetBootId(): void {
   currentBootId = null;
-}
+}

package/packages/core/src/storage/bootstrap.ts

@@ -0,0 +1,151 @@
+/**
+ * HiveDB bootstrap — replaces initializeDatabase() + seedAllData() +
+ * runStartupMigrations().
+ *
+ * A brand-new install never has legacy SQLite data to migrate, so there is
+ * no version-gated migration list: ensureHiveDb() just makes sure every
+ * collection's secondary indexes exist (idempotent, safe every boot) and
+ * that the static catalogs are (re)seeded from their canonical source
+ * (SEED_DATA / SkillLoader) — same "reseed every boot so code changes
+ * always take effect" behavior `seedAllData()` had, just via `put()`
+ * instead of `DELETE`+`INSERT`.
+ */
+
+import { getHiveDb } from "./hivedb";
+import { col } from "./hive";
+import { seedAllData } from "./seed";
+import { ensureSecretsBackend } from "./crypto";
+
+interface IndexSpec {
+  collection: string;
+  field: string;
+  unique?: boolean;
+}
+
+/**
+ * Every equality index used by `findBy()` across the codebase. Grouped by
+ * the migration stage that introduces the collection; kept in one place so
+ * a missing index is a loud error (`findBy` throws) rather than a silent
+ * empty result.
+ */
+const INDEXES: IndexSpec[] = [
+  // Stage 1 — identity/config core
+  { collection: "models", field: "provider_id" },
+  { collection: "models", field: "model_type" },
+  { collection: "agents", field: "user_id" },
+  { collection: "agents", field: "model_id" },
+  { collection: "agents", field: "parent_id" },
+  { collection: "agents", field: "role" },
+  { collection: "agents", field: "status" },
+  { collection: "agents", field: "source" },
+  // Stage 2 — catalog
+  { collection: "channels", field: "user_id" },
+  { collection: "channels", field: "type" },
+  { collection: "skills", field: "category" },
+  { collection: "skills", field: "active" },
+  { collection: "tools", field: "category" },
+  { collection: "tools", field: "active" },
+  { collection: "ethics", field: "active" },
+  { collection: "mcpTools", field: "server_id" },
+  { collection: "mcpTools", field: "active" },
+  // Stage 3 — auth/identity
+  { collection: "userChannels", field: "channel" },
+  { collection: "refreshTokens", field: "token_hash", unique: true },
+  { collection: "refreshTokens", field: "user_id" },
+  { collection: "notifications", field: "user_id" },
+  { collection: "notifications", field: "channel" },
+  // Stage 4 — chat/ACE
+  { collection: "traces", field: "thread_id" },
+  { collection: "traces", field: "agent_id" },
+  { collection: "traces", field: "success" },
+  { collection: "playbook", field: "active" },
+  { collection: "playbook", field: "category" },
+  // Stage 5 — scheduler
+  { collection: "cronJobs", field: "status" },
+  { collection: "cronJobs", field: "task_type" },
+  { collection: "cronJobs", field: "agent_id" },
+  { collection: "agentRuns", field: "status" },
+  { collection: "agentRuns", field: "thread_id" },
+  { collection: "agentRuns", field: "agent_id" },
+  { collection: "agentRuns", field: "kind" },
+  { collection: "agentRuns", field: "catalog_agent_id" },
+  { collection: "jobQueue", field: "status" },
+  { collection: "jobQueue", field: "lane" },
+  { collection: "jobQueue", field: "type" },
+  { collection: "jobQueue", field: "run_id" },
+  { collection: "jobQueue", field: "idempotency_key" },
+  { collection: "proofPackets", field: "run_id" },
+  { collection: "proofPackets", field: "agent_id" },
+  { collection: "proofPackets", field: "catalog_agent_id" },
+  { collection: "artifacts", field: "run_id" },
+  { collection: "artifacts", field: "task_id" },
+  { collection: "artifacts", field: "user_id" },
+  { collection: "artifacts", field: "status" },
+  { collection: "agentProposals", field: "agent_id" },
+  { collection: "agentProposals", field: "status" },
+  { collection: "agentProposals", field: "type" },
+  // Stage 6 — orchestration
+  { collection: "tasks", field: "agent_id" },
+  { collection: "tasks", field: "status" },
+  { collection: "tasks", field: "catalog_agent_id" },
+  { collection: "tasks", field: "delegation_group_id" },
+  { collection: "delegationGroups", field: "turn_id", unique: true },
+  { collection: "delegationGroups", field: "thread_id" },
+  { collection: "delegationGroups", field: "status" },
+  { collection: "agentBusMessages", field: "to_worker_id" },
+  { collection: "agentBusMessages", field: "from_worker_id" },
+  { collection: "agentBusMessages", field: "event_type" },
+  { collection: "narrationEvents", field: "turn_id" },
+  { collection: "narrationEvents", field: "thread_id" },
+  { collection: "narrationEvents", field: "user_id" },
+  { collection: "narrationEvents", field: "kind" },
+  // Stage 7 — meeting
+  { collection: "meetingSessions", field: "user_id" },
+  { collection: "meetingSessions", field: "status" },
+];
+
+async function ensureIndexes(): Promise<void> {
+  for (const spec of INDEXES) {
+    const c = await col(spec.collection);
+    await c.createIndex(spec.field, { unique: spec.unique });
+  }
+}
+
+/**
+ * Seeds the static catalogs (tools, skills, providers, models, mcp servers,
+ * channels, ethics, ACE playbook) from their canonical source every boot —
+ * same "reseed every boot so code changes always take effect" behavior the
+ * old SQLite seedAllData() had. Fully idempotent: uses putIfAbsent for
+ * user-toggleable fields (enabled/active) and doesn't touch `users`, so it's
+ * safe to call unconditionally before any onboarding has happened.
+ */
+async function ensureSeedData(): Promise<void> {
+  await seedAllData();
+}
+
+let bootstrapped = false;
+
+/**
+ * Idempotent entry point: opens the database, ensures indexes, reseeds the
+ * static catalogs, and records the schema version. Safe to call on every
+ * gateway boot.
+ */
+export async function ensureHiveDb(): Promise<void> {
+  await getHiveDb();
+  await ensureIndexes();
+  // Mint the master key before anything can save an API key, so a fresh
+  // install is durable from the first keystroke rather than after a restart
+  // has already dropped the secret.
+  ensureSecretsBackend();
+  await ensureSeedData();
+
+  const meta = await col<{ value: number }>("meta");
+  const existing = await meta.get("schemaVersion");
+  if (!existing) await meta.put("schemaVersion", { value: 1 }, { expectedVersion: 0 });
+
+  bootstrapped = true;
+}
+
+export function isBootstrapped(): boolean {
+  return bootstrapped;
+}

package/packages/core/src/storage/causal-events.ts

@@ -0,0 +1,84 @@
+/**
+ * Live-tail wrapper over HiveDB's G9 causal event log (subscribe()/events()).
+ *
+ * Read-side, separate from agent-loop.ts's write-side appendCausalEvent()
+ * (module-private there, write-only). This is the read/watch counterpart,
+ * co-located with the DB singleton accessor.
+ */
+
+import { getHiveDb } from "./hivedb"
+import type { Event, EventPattern } from "@johpaz/hive-db"
+
+export type { Event as CausalEvent, EventPattern as CausalEventPattern }
+
+/**
+ * Live-tail causal events matching `pattern`. Forward-only: only events
+ * appended AFTER this call resolves are delivered. hive-db's subscribe()/
+ * events() are a pure in-process pub/sub (see hiveBD's reactive.rs — a
+ * DashMap of subscribers, dispatched right after the durable write, with no
+ * backing read of the log on subscribe) — there is no historical replay.
+ * Combine with causalThread()/read(seq) if backfill is ever needed.
+ *
+ * Note: `pattern.kind` matches exactly one kind at a time, not an OR of
+ * several — call watchCausalEvents() once per kind if you need more than one.
+ *
+ * Process constraint (confirmed by testing): getHiveDb() opens the database
+ * exclusively — there is no shared/read-only mode, so this can only be
+ * called from within the SAME process as whatever else has the DB open
+ * (e.g. embedded inside the gateway). A separate process (like the `hive
+ * causal watch` CLI) calling this while a `hive` gateway is already running
+ * against the same DB fails fast with an "already open" error.
+ */
+export async function watchCausalEvents(
+  pattern: EventPattern
+): Promise<AsyncIterable<Event> & { close(): void }> {
+  const db = await getHiveDb()
+  return db.events(pattern)
+}
+
+/** One-line human-readable summary of a causal event, keyed by its kindTag. */
+export function formatCausalEvent(event: Event): string {
+  let payload: Record<string, unknown> = {}
+  try {
+    payload = JSON.parse(event.payload)
+  } catch {
+    // Malformed payload — still print seq/kind/agent/stream below.
+  }
+
+  const streamShort = event.streamId.slice(0, 8)
+  const header = `[${event.seq}] ${kindIcon(event.kindTag)} ${event.kindTag.padEnd(16)} agent=${event.agentId}  stream=${streamShort}…`
+
+  switch (event.kindTag) {
+    case "IntentLogged":
+      return `${header}  "${truncate(String(payload.intent ?? ""), 120)}"`
+    case "StateTransition":
+      return `${header}  "${truncate(String(payload.description ?? ""), 120)}"`
+    case "ToolCall": {
+      const outcome = payload.outcome
+      const outcomeStr =
+        outcome === "Ok" ? "ok"
+        : outcome === "Timeout" ? "TIMEOUT"
+        : (outcome && typeof outcome === "object" && "Err" in (outcome as object))
+          ? `ERR: ${(outcome as { Err: string }).Err}`
+          : String(outcome)
+      const latency = payload.latency_ms !== undefined ? `${payload.latency_ms}ms` : "?ms"
+      return `${header}  tool=${payload.tool}  ${latency}  ${outcomeStr}`
+    }
+    default:
+      return `${header}  ${truncate(JSON.stringify(payload), 120)}`
+  }
+}
+
+function kindIcon(kindTag: string): string {
+  switch (kindTag) {
+    case "IntentLogged": return "🎯"
+    case "StateTransition": return "🔀"
+    case "ToolCall": return "🔧"
+    case "LearningProposal": return "📄"
+    default: return "•"
+  }
+}
+
+function truncate(s: string, max: number): string {
+  return s.length > max ? s.slice(0, max) + "…" : s
+}