@johpaz/hive-sdk 0.1.4 → 0.1.6

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

@@ -1,236 +0,0 @@
-/**
- * Harness module tests — job-store retry/idempotency, durable-queue
- * dispatch + retry wiring, run-store checkpoint/acceptance/epoch
- * round-trip, proof-packet persistence, goal-verifier (deterministic
- * check-tool + acceptance-criteria paths only — no network/LLM calls).
- *
- * Uses an isolated HIVE_HOME so this never touches a real dev database.
- */
-
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { closeHiveDB } from "../storage/HiveDBStorage.ts";
-import {
-  ensureHarnessIndexes,
-  createJob,
-  claimJob,
-  failJobOrRetry,
-  getJob,
-  computeBackoffDelay,
-  findByIdempotencyKey,
-  DurableLaneQueue,
-  registerExecutor,
-  createRun,
-  deserializeAcceptance,
-  deserializeEpoch,
-  buildRunEpoch,
-  buildProofPacket,
-  findProofPacketsByRun,
-  verifyGoal,
-  getBootId,
-  resetBootId,
-  col,
-  type JobRetryPolicy,
-  type JobDoc,
-} from "./index.ts";
-
-// Fresh HiveDB directory per test — hive-sdk's HiveDBStorage has no ":memory:"
-// mode, so isolation means pointing HIVE_HOME at a new temp dir each time and
-// letting the lazy singleton reopen there.
-let currentDir: string;
-
-beforeEach(async () => {
-  closeHiveDB();
-  resetBootId();
-  currentDir = mkdtempSync(path.join(tmpdir(), "hive-sdk-harness-test-"));
-  process.env.HIVE_HOME = currentDir;
-  await ensureHarnessIndexes();
-});
-
-afterEach(() => {
-  closeHiveDB();
-  rmSync(currentDir, { recursive: true, force: true });
-});
-
-const FAST_POLICY: JobRetryPolicy = {
-  maxRetries: 2,
-  initialDelayMs: 10,
-  backoffMultiplier: 2,
-  maxDelayMs: 1000,
-  jitter: 0,
-};
-
-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, 10));
-  }
-  throw new Error("waitFor timed out");
-}
-
-describe("harness/job-store: idempotency", () => {
-  test("repeated idempotency_key returns the same job", async () => {
-    const first = await createJob({ lane: "s1", type: "worker_task", payload: { n: 1 }, run_id: "r1", idempotency_key: "dedupe-1" });
-    const second = await createJob({ lane: "s1", type: "worker_task", payload: { n: 2 }, run_id: "r1", idempotency_key: "dedupe-1" });
-    expect(second.id).toBe(first.id);
-    expect(JSON.parse(second.payload_json).n).toBe(1);
-  });
-
-  test("findByIdempotencyKey returns null for an unknown key", async () => {
-    expect(await findByIdempotencyKey("nope")).toBeNull();
-  });
-});
-
-describe("harness/job-store: retry/backoff", () => {
-  test("computeBackoffDelay grows exponentially and caps", () => {
-    const policy: JobRetryPolicy = { maxRetries: 10, initialDelayMs: 100, backoffMultiplier: 2, maxDelayMs: 500, jitter: 0 };
-    expect(computeBackoffDelay(0, policy)).toBe(100);
-    expect(computeBackoffDelay(1, policy)).toBe(200);
-    expect(computeBackoffDelay(3, policy)).toBe(500);
-  });
-
-  test("failJobOrRetry schedules a retry, then fails terminally after maxRetries", async () => {
-    const job = await createJob({ lane: "s2", type: "worker_task", payload: {}, run_id: "r2" });
-    const c = await col<JobDoc>("harness_jobQueue");
-    // Force not_before into the past after each retry so claimJob doesn't block on the backoff delay.
-    const forcePastNotBefore = async () => {
-      const entry = await c.get(job.id);
-      await c.put(job.id, { ...entry!.doc, not_before: Date.now() - 1 }, { expectedVersion: entry!.version });
-    };
-
-    await claimJob(job.id);
-    const r1 = await failJobOrRetry(job.id, "boom", getBootId(), FAST_POLICY);
-    expect(r1!.status).toBe("pending");
-    expect(r1!.retry_count).toBe(1);
-    await forcePastNotBefore();
-
-    await claimJob(job.id);
-    const r2 = await failJobOrRetry(job.id, "boom again", getBootId(), FAST_POLICY);
-    expect(r2!.status).toBe("pending");
-    expect(r2!.retry_count).toBe(2);
-    await forcePastNotBefore();
-
-    await claimJob(job.id);
-    const r3 = await failJobOrRetry(job.id, "final", getBootId(), FAST_POLICY);
-    expect(r3!.status).toBe("failed");
-  });
-});
-
-describe("harness/durable-queue", () => {
-  let queue: DurableLaneQueue | null = null;
-
-  afterEach(() => {
-    queue?.stop();
-    queue = null;
-  });
-
-  test("retries a retryable logical failure then completes", async () => {
-    let calls = 0;
-    registerExecutor("flaky_task", async () => {
-      calls++;
-      if (calls < 2) return { ok: false, error: "flaky", retryable: true };
-      return { ok: true, result: "recovered" };
-    });
-
-    queue = new DurableLaneQueue({ maxGlobalConcurrency: 2, jobRetryPolicy: FAST_POLICY });
-    const job = await queue.enqueue({ lane: "lane-flaky", type: "flaky_task", run_id: "r3", payload: {} });
-
-    await waitFor(async () => (await getJob(job.id))?.retry_count === 1);
-    await new Promise((r) => setTimeout(r, 30));
-    queue.start();
-
-    await waitFor(async () => (await getJob(job.id))?.status === "completed");
-    expect(calls).toBe(2);
-  });
-
-  test("nonRetryableTypes never auto-retries a logical failure", async () => {
-    let calls = 0;
-    registerExecutor("chat_turn", async () => {
-      calls++;
-      return { ok: false, error: "user-facing failure" };
-    });
-
-    queue = new DurableLaneQueue({ maxGlobalConcurrency: 2, jobRetryPolicy: FAST_POLICY });
-    const job = await queue.enqueue({ lane: "lane-chat", type: "chat_turn", run_id: "r4", payload: {} });
-
-    await waitFor(async () => (await getJob(job.id))?.status === "failed");
-    expect(calls).toBe(1);
-    expect((await getJob(job.id))!.retry_count).toBe(0);
-  });
-});
-
-describe("harness/run-store: acceptance + epoch round-trip", () => {
-  test("createRun persists and deserializes acceptance criteria and epoch", async () => {
-    const epoch = buildRunEpoch({ provider: "anthropic", model: "claude-x", appVersion: "1.2.3", toolNames: ["search", "exec"] });
-    const run = await createRun({
-      thread_id: "t1",
-      agent_id: "a1",
-      user_id: "u1",
-      channel: null,
-      kind: "goal",
-      max_iterations: 20,
-      acceptance: [
-        { id: "c1", description: "responds in Spanish" },
-        { id: "c2", description: "calls the search tool", checkTool: "search" },
-      ],
-      epoch,
-    });
-
-    const acceptance = deserializeAcceptance(run);
-    expect(acceptance).not.toBeNull();
-    expect(acceptance!.length).toBe(2);
-    expect(acceptance![1].checkTool).toBe("search");
-    expect(deserializeEpoch(run)).toEqual(epoch);
-  });
-});
-
-describe("harness/proof-packet", () => {
-  test("persists and retrieves a proof packet", async () => {
-    const packet = await buildProofPacket({
-      runId: "run-proof-1",
-      agentId: "a1",
-      intendedOutcome: "send the weekly report",
-      met: true,
-      checksRun: ["llm_verifier"],
-      evidence: ["report sent"],
-    });
-    expect(packet.met).toBe(true);
-    const found = await findProofPacketsByRun("run-proof-1");
-    expect(found.length).toBe(1);
-    expect(found[0].id).toBe(packet.id);
-  });
-});
-
-describe("harness/goal-verifier: deterministic check-tool path (no LLM)", () => {
-  test("a single boolean-returning check tool is interpreted directly", async () => {
-    const verdict = await verifyGoal({
-      goal: "workspace exists",
-      checkTool: "check_workspace",
-      messages: [],
-      providerCfg: { provider: "anthropic", model: "x", apiKey: "unused" },
-      runCheckTool: async () => true,
-    });
-    expect(verdict.met).toBe(true);
-  });
-
-  test("acceptance criteria aggregate as a conjunction across check tools", async () => {
-    const verdict = await verifyGoal({
-      goal: "onboard client",
-      messages: [],
-      providerCfg: { provider: "anthropic", model: "x", apiKey: "unused" },
-      runCheckTool: async (tool) => (tool === "check_a" ? true : { met: false, reason: "email not sent" }),
-      acceptance: [
-        { id: "c1", description: "workspace created", checkTool: "check_a" },
-        { id: "c2", description: "welcome email sent", checkTool: "check_b" },
-      ],
-    });
-    expect(verdict.met).toBe(false);
-    expect(verdict.acceptanceResults).toHaveLength(2);
-    expect(verdict.acceptanceResults![0].met).toBe(true);
-    expect(verdict.acceptanceResults![1].met).toBe(false);
-  });
-});

package/packages/core/src/harness/reconcile.ts

@@ -1,149 +0,0 @@
-/**
- * reconcileOnBoot — repair harness rows left in inconsistent states by a
- * previous crash/kill, plus a retention cap. Ported from `hive`'s
- * storage/reconcile.ts, trimmed to only the generic harness collections
- * (agentRuns/jobQueue) — `hive`'s version also repairs app-specific rows
- * (taskRuns, meetingSessions, project tasks) that don't exist in the SDK.
- *
- * Call early in a host app's boot sequence, before `initDurableQueue`.
- */
-
-import { col } from "./db-helpers";
-import type { HarnessRunDoc } from "./collections";
-import type { JobDoc } from "./collections";
-import { logger } from "../utils/logger";
-import { reclaimOrInterrupt, JOB_QUEUE_COLLECTION } from "./job-store";
-import { interruptRun, AGENT_RUNS_COLLECTION } from "./run-store";
-
-const log = logger.child("harness:reconcile");
-
-export interface ReconcileResult {
-  bootId: string;
-  runsInterrupted: number;
-  runsReEnqueueable: number;
-  jobsReclaimed: number;
-  jobsInterrupted: number;
-  runsPruned: number;
-  jobsPruned: number;
-}
-
-export interface ReconcileOptions {
-  /** Run kinds treated as "interactive" (interrupted outright rather than flagged for re-enqueue). Default: ["chat"]. */
-  interactiveKinds?: string[];
-  /** Retention cap per thread/run. Default: 500. */
-  retentionLimit?: number;
-  /** Called when an interactive run is interrupted, so the host can notify the user. */
-  onInteractiveInterrupted?: (run: HarnessRunDoc) => Promise<void> | void;
-}
-
-export async function reconcileOnBoot(bootId: string, opts: ReconcileOptions = {}): Promise<ReconcileResult> {
-  const interactiveKinds = new Set(opts.interactiveKinds ?? ["chat"]);
-  const retentionLimit = opts.retentionLimit ?? 500;
-
-  log.info(`[reconcileOnBoot] Starting with boot_id=${bootId}`);
-  const result: ReconcileResult = {
-    bootId,
-    runsInterrupted: 0,
-    runsReEnqueueable: 0,
-    jobsReclaimed: 0,
-    jobsInterrupted: 0,
-    runsPruned: 0,
-    jobsPruned: 0,
-  };
-
-  // 1. harness_agentRuns: any "running" row is orphaned at boot — HiveDB is
-  // single-process and this process just started, so no run can actually be
-  // executing.
-  try {
-    const runsCol = await col<HarnessRunDoc>(AGENT_RUNS_COLLECTION);
-    const runningRuns = await runsCol.findBy("status", "running");
-    for (const entry of runningRuns) {
-      const run = entry.doc;
-      if (interactiveKinds.has(run.kind)) {
-        await interruptRun(run.id, "Process restarted while an interactive run was in flight");
-        result.runsInterrupted++;
-        try {
-          await opts.onInteractiveInterrupted?.(run);
-        } catch {
-          // non-critical
-        }
-      } else {
-        await interruptRun(run.id, "Process restarted — job will be re-enqueued if durable");
-        result.runsReEnqueueable++;
-      }
-    }
-    if (result.runsInterrupted > 0 || result.runsReEnqueueable > 0) {
-      log.info(`[reconcileOnBoot] ${result.runsInterrupted} interactive runs interrupted, ${result.runsReEnqueueable} durable runs flagged for re-enqueue`);
-    }
-  } catch (err) {
-    log.warn(`[reconcileOnBoot] Failed to repair agentRuns: ${(err as Error).message}`);
-  }
-
-  // 2. harness_jobQueue: any "running" row is orphaned at boot (same
-  // single-process argument as above) → reclaim (pending) or interrupt,
-  // ignoring the lease.
-  try {
-    const jobsCol = await col<JobDoc>(JOB_QUEUE_COLLECTION);
-    const runningJobs = await jobsCol.findBy("status", "running");
-    for (const entry of runningJobs) {
-      const doc = await reclaimOrInterrupt(entry.doc.id, { force: true });
-      if (doc?.status === "pending") result.jobsReclaimed++;
-      else if (doc?.status === "interrupted") result.jobsInterrupted++;
-    }
-    if (result.jobsReclaimed > 0 || result.jobsInterrupted > 0) {
-      log.info(`[reconcileOnBoot] ${result.jobsReclaimed} jobs reclaimed to pending, ${result.jobsInterrupted} jobs interrupted (attempts exhausted)`);
-    }
-  } catch (err) {
-    log.warn(`[reconcileOnBoot] Failed to repair jobQueue: ${(err as Error).message}`);
-  }
-
-  // 3. Retention cap: keep only the most recent N agentRuns/jobs per thread/run.
-  try {
-    const runsCol = await col<HarnessRunDoc>(AGENT_RUNS_COLLECTION);
-    const allRuns = await runsCol.scan({});
-    const runsByThread = new Map<string, typeof allRuns>();
-    for (const entry of allRuns) {
-      const key = entry.doc.thread_id ?? entry.doc.agent_id ?? "_default";
-      const list = runsByThread.get(key) ?? [];
-      list.push(entry);
-      runsByThread.set(key, list);
-    }
-    for (const [, runs] of runsByThread) {
-      if (runs.length <= retentionLimit) continue;
-      const sorted = runs.sort((a, b) => (b.doc.created_at ?? 0) - (a.doc.created_at ?? 0));
-      for (const entry of sorted.slice(retentionLimit)) {
-        await runsCol.delete(entry.id);
-        result.runsPruned++;
-      }
-    }
-    if (result.runsPruned > 0) {
-      log.info(`[reconcileOnBoot] Retention: pruned ${result.runsPruned} old agentRuns (cap=${retentionLimit}/thread)`);
-    }
-
-    const jobsCol = await col<JobDoc>(JOB_QUEUE_COLLECTION);
-    const allJobs = await jobsCol.scan({});
-    const jobsByRun = new Map<string, typeof allJobs>();
-    for (const entry of allJobs) {
-      const key = entry.doc.run_id ?? "_default";
-      const list = jobsByRun.get(key) ?? [];
-      list.push(entry);
-      jobsByRun.set(key, list);
-    }
-    for (const [, jobs] of jobsByRun) {
-      if (jobs.length <= retentionLimit) continue;
-      const sorted = jobs.sort((a, b) => (b.doc.created_at ?? 0) - (a.doc.created_at ?? 0));
-      for (const entry of sorted.slice(retentionLimit)) {
-        await jobsCol.delete(entry.id);
-        result.jobsPruned++;
-      }
-    }
-    if (result.jobsPruned > 0) {
-      log.info(`[reconcileOnBoot] Retention: pruned ${result.jobsPruned} old jobs (cap=${retentionLimit}/run)`);
-    }
-  } catch (err) {
-    log.warn(`[reconcileOnBoot] Failed to enforce retention cap: ${(err as Error).message}`);
-  }
-
-  log.info(`[reconcileOnBoot] Done`, result);
-  return result;
-}

package/packages/core/src/mcp/MCPToolAdapter.ts

@@ -1,176 +0,0 @@
-/**
- * MCP Tool Sync — Persist MCP tool definitions to DB and FTS5
- *
- * When an MCP server connects, its tool definitions are persisted to
- * the mcp_tools table and indexed in mcp_tools_fts for search_knowledge.
- * When the server disconnects, all its tools are deleted from both.
- *
- * This enables:
- * 1. search_knowledge to find MCP tools via FTS5
- * 2. Tool definitions to survive across context compiler invocations
- * 3. Offline visibility of what MCP tools were available
- */
-
-import { getDb } from "../storage/SQLiteStorage.ts"
-import { logger } from "../utils/logger.ts"
-
-const log = logger.child("mcp:tool-sync")
-
-export interface MCPToolDefinition {
-    name: string
-    description: string
-    inputSchema?: Record<string, unknown>
-}
-
-/**
- * Generate a stable ID for an MCP tool based on server + tool name.
- * Uses the same sanitization as mcpToolFullName for consistency.
- */
-export function mcpToolId(serverName: string, toolName: string): string {
-    const safe = (s: string) => s.replace(/\s+/g, '_').replace(/[^a-zA-Z0-9_.\-:]/g, '_')
-    const full = `${safe(serverName)}__${safe(toolName)}`
-    const trimmed = full.length > 64 ? full.substring(0, 64) : full
-    return /^[a-zA-Z_]/.test(trimmed) ? trimmed : `_${trimmed}`.substring(0, 64)
-}
-
-/**
- * Persist MCP tool definitions to the mcp_tools table.
- * Called when a server connects or reconnects.
- * Deletes existing tools for the server first, then inserts fresh data.
- */
-export function syncMCPToolsToDB(
-    serverId: string,
-    serverName: string,
-    tools: MCPToolDefinition[]
-): void {
-    const db = getDb()
-
-    try {
-        const deleteExisting = db.prepare("DELETE FROM mcp_tools WHERE server_id = ?")
-        deleteExisting.run(serverId)
-
-        if (tools.length === 0) {
-            log.debug(`[mcp:tool-sync] No tools to persist for server ${serverName}`)
-            return
-        }
-
-        const insertTool = db.prepare(`
-            INSERT INTO mcp_tools(id, server_id, server_name, tool_name, description, category, active, created_at, updated_at)
-            VALUES (?, ?, ?, ?, ?, 'mcp', 1, (unixepoch()), (unixepoch()))
-        `)
-
-        let count = 0
-        for (const tool of tools) {
-            const id = mcpToolId(serverName, tool.name)
-            insertTool.run(id, serverId, serverName, tool.name, tool.description || "")
-            count++
-        }
-
-        log.info(`[mcp:tool-sync] Persisted ${count} MCP tools for server ${serverName} to mcp_tools`)
-    } catch (err) {
-        log.error(`[mcp:tool-sync] Failed to persist MCP tools for server ${serverName}:`, err)
-    }
-}
-
-/**
- * Sync all active MCP tools from mcp_tools table to mcp_tools_fts.
- * Called after syncMCPToolsToDB or after startup to ensure FTS5 is in sync.
- *
- * This does a full clear + re-insert to avoid schema drift.
- */
-export async function syncMCPToolsToFTS(): Promise<void> {
-    const db = getDb()
-
-    try {
-        const syncTransaction = db.transaction(() => {
-            // Verify table exists
-            const tableCheck = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='mcp_tools_fts'").get()
-            if (!tableCheck) {
-                throw new Error("mcp_tools_fts table does not exist!")
-            }
-
-            // Clear existing FTS data
-            db.run("DELETE FROM mcp_tools_fts")
-
-            // Re-populate from mcp_tools where active
-            const mcpTools = db.query(`
-                SELECT id, server_name, tool_name, description, category
-                FROM mcp_tools
-                WHERE active = 1
-            `).all() as Array<{ id: string; server_name: string; tool_name: string; description: string; category: string }>
-
-            if (mcpTools.length === 0) {
-                log.debug(`[mcp:tool-sync] No MCP tools to sync to FTS5`)
-                return
-            }
-
-            const insert = db.prepare(`
-                INSERT INTO mcp_tools_fts(id, server_name, tool_name, description, category)
-                VALUES (?, ?, ?, ?, ?)
-            `)
-
-            for (const tool of mcpTools) {
-                insert.run(tool.id, tool.server_name, tool.tool_name, tool.description, tool.category)
-            }
-
-            log.info(`[mcp:tool-sync] Synced ${mcpTools.length} MCP tools to mcp_tools_fts`)
-        })
-
-        syncTransaction()
-    } catch (err) {
-        log.error(`[mcp:tool-sync] Failed to sync MCP tools to FTS5:`, err)
-    }
-}
-
-/**
- * Delete all MCP tool definitions for a server from both mcp_tools and mcp_tools_fts.
- * Called when a server disconnects or is removed.
- */
-export function clearMCPToolsFromDB(serverId: string): void {
-    const db = getDb()
-
-    try {
-        // Delete from mcp_tools (CASCADE will handle FTS5 via trigger or manual sync)
-        const result = db.query("DELETE FROM mcp_tools WHERE server_id = ?").run(serverId)
-
-        log.info(`[mcp:tool-sync] Cleared MCP tools for server_id=${serverId}`)
-
-        // Re-sync FTS5 to remove stale entries
-        syncMCPToolsToFTSSync()
-    } catch (err) {
-        log.error(`[mcp:tool-sync] Failed to clear MCP tools for server_id=${serverId}:`, err)
-    }
-}
-
-/**
- * Synchronous version of syncMCPToolsToFTS for use in clearMCPToolsFromDB.
- * Avoids async/await in transaction that was already started.
- */
-function syncMCPToolsToFTSSync(): void {
-    const db = getDb()
-
-    try {
-        db.run("DELETE FROM mcp_tools_fts")
-
-        const mcpTools = db.query(`
-            SELECT id, server_name, tool_name, description, category
-            FROM mcp_tools
-            WHERE active = 1
-        `).all() as Array<{ id: string; server_name: string; tool_name: string; description: string; category: string }>
-
-        if (mcpTools.length === 0) return
-
-        const insert = db.prepare(`
-            INSERT INTO mcp_tools_fts(id, server_name, tool_name, description, category)
-            VALUES (?, ?, ?, ?, ?)
-        `)
-
-        for (const tool of mcpTools) {
-            insert.run(tool.id, tool.server_name, tool.tool_name, tool.description, tool.category)
-        }
-
-        log.debug(`[mcp:tool-sync] Re-synced ${mcpTools.length} MCP tools to FTS5 after deletion`)
-    } catch (err) {
-        log.error(`[mcp:tool-sync] Failed to re-sync MCP tools to FTS5:`, err)
-    }
-}