opencode-swarm-plugin 0.26.0 → 0.27.0

package/src/{beads.integration.test.ts → hive.integration.test.ts}

@@ -1,27 +1,39 @@
 /**
- * Beads Integration Tests
+ * Hive Integration Tests
  *
- * These tests exercise the BeadsAdapter-based tools directly.
- * They validate the tool wrappers work correctly with actual beads operations.
+ * These tests exercise the HiveAdapter-based tools directly.
+ * They validate the tool wrappers work correctly with actual hive operations.
  *
- * Run with: bun test src/beads.integration.test.ts
+ * Run with: bun test src/hive.integration.test.ts
  */
 import { describe, it, expect, beforeAll, beforeEach, afterAll } from "vitest";
 import {
-  beads_create,
-  beads_create_epic,
-  beads_query,
-  beads_update,
-  beads_close,
-  beads_start,
-  beads_ready,
+  hive_create,
+  hive_create_epic,
+  hive_query,
+  hive_update,
+  hive_close,
+  hive_start,
+  hive_ready,
+  hive_link_thread,
+  HiveError,
+  getHiveAdapter,
+  setHiveWorkingDirectory,
+  // Legacy aliases for backward compatibility tests
+  hive_create,
+  hive_create_epic,
+  hive_query,
+  hive_update,
+  hive_close,
+  hive_start,
+  hive_ready,
   beads_link_thread,
   BeadError,
   getBeadsAdapter,
   setBeadsWorkingDirectory,
-} from "./beads";
-import type { Bead, EpicCreateResult } from "./schemas";
-import type { BeadsAdapter } from "swarm-mail";
+} from "./hive";
+import type { Cell, Bead, EpicCreateResult } from "./schemas";
+import type { HiveAdapter } from "swarm-mail";
 
 /**
  * Mock tool context for execute functions
@@ -54,7 +66,7 @@ const TEST_PROJECT_KEY = `/tmp/beads-integration-test-${Date.now()}`;
 /**
  * Adapter instance for verification
  */
-let adapter: BeadsAdapter;
+let adapter: HiveAdapter;
 
 /**
  * Cleanup helper - close all created beads after tests
@@ -62,7 +74,7 @@ let adapter: BeadsAdapter;
 async function cleanupBeads() {
   for (const id of createdBeadIds) {
     try {
-      await beads_close.execute({ id, reason: "Test cleanup" }, mockContext);
+      await hive_close.execute({ id, reason: "Test cleanup" }, mockContext);
     } catch {
       // Ignore cleanup errors - bead may already be closed
     }
@@ -84,9 +96,9 @@ describe("beads integration", () => {
     await cleanupBeads();
   });
 
-  describe("beads_create", () => {
+  describe("hive_create", () => {
     it("creates a bead with minimal args (title only)", async () => {
-      const result = await beads_create.execute(
+      const result = await hive_create.execute(
         { title: "Test bead minimal" },
         mockContext,
       );
@@ -102,7 +114,7 @@ describe("beads integration", () => {
     });
 
     it("creates a bead with all options", async () => {
-      const result = await beads_create.execute(
+      const result = await hive_create.execute(
         {
           title: "Test bug with priority",
           type: "bug",
@@ -122,7 +134,7 @@ describe("beads integration", () => {
     });
 
     it("creates a feature type bead", async () => {
-      const result = await beads_create.execute(
+      const result = await hive_create.execute(
         { title: "New feature request", type: "feature", priority: 1 },
         mockContext,
       );
@@ -135,7 +147,7 @@ describe("beads integration", () => {
     });
 
     it("creates a chore type bead", async () => {
-      const result = await beads_create.execute(
+      const result = await hive_create.execute(
         { title: "Cleanup task", type: "chore", priority: 3 },
         mockContext,
       );
@@ -148,12 +160,12 @@ describe("beads integration", () => {
     });
   });
 
-  describe("beads_query", () => {
+  describe("hive_query", () => {
     let testBeadId: string;
 
     beforeEach(async () => {
       // Create a test bead for query tests
-      const result = await beads_create.execute(
+      const result = await hive_create.execute(
         { title: "Query test bead", type: "task" },
         mockContext,
       );
@@ -163,7 +175,7 @@ describe("beads integration", () => {
     });
 
     it("queries all open beads", async () => {
-      const result = await beads_query.execute({ status: "open" }, mockContext);
+      const result = await hive_query.execute({ status: "open" }, mockContext);
 
       const beads = parseResponse<Bead[]>(result);
 
@@ -173,7 +185,7 @@ describe("beads integration", () => {
     });
 
     it("queries beads by type", async () => {
-      const result = await beads_query.execute({ type: "task" }, mockContext);
+      const result = await hive_query.execute({ type: "task" }, mockContext);
 
       const beads = parseResponse<Bead[]>(result);
 
@@ -182,7 +194,7 @@ describe("beads integration", () => {
     });
 
     it("queries ready beads (unblocked)", async () => {
-      const result = await beads_query.execute({ ready: true }, mockContext);
+      const result = await hive_query.execute({ ready: true }, mockContext);
 
       const beads = parseResponse<Bead[]>(result);
 
@@ -196,7 +208,7 @@ describe("beads integration", () => {
     it("limits results", async () => {
       // Create multiple beads first
       for (let i = 0; i < 5; i++) {
-        const result = await beads_create.execute(
+        const result = await hive_create.execute(
           { title: `Limit test bead ${i}` },
           mockContext,
         );
@@ -204,14 +216,14 @@ describe("beads integration", () => {
         createdBeadIds.push(bead.id);
       }
 
-      const result = await beads_query.execute({ limit: 3 }, mockContext);
+      const result = await hive_query.execute({ limit: 3 }, mockContext);
 
       const beads = parseResponse<Bead[]>(result);
       expect(beads.length).toBeLessThanOrEqual(3);
     });
 
     it("combines filters", async () => {
-      const result = await beads_query.execute(
+      const result = await hive_query.execute(
         { status: "open", type: "task", limit: 5 },
         mockContext,
       );
@@ -227,11 +239,11 @@ describe("beads integration", () => {
     });
   });
 
-  describe("beads_update", () => {
+  describe("hive_update", () => {
     let testBeadId: string;
 
     beforeEach(async () => {
-      const result = await beads_create.execute(
+      const result = await hive_create.execute(
         { title: "Update test bead", description: "Original description" },
         mockContext,
       );
@@ -241,7 +253,7 @@ describe("beads integration", () => {
     });
 
     it("updates bead status", async () => {
-      const result = await beads_update.execute(
+      const result = await hive_update.execute(
         { id: testBeadId, status: "in_progress" },
         mockContext,
       );
@@ -251,7 +263,7 @@ describe("beads integration", () => {
     });
 
     it("updates bead description", async () => {
-      const result = await beads_update.execute(
+      const result = await hive_update.execute(
         { id: testBeadId, description: "Updated description" },
         mockContext,
       );
@@ -261,7 +273,7 @@ describe("beads integration", () => {
     });
 
     it("updates bead priority", async () => {
-      const result = await beads_update.execute(
+      const result = await hive_update.execute(
         { id: testBeadId, priority: 0 },
         mockContext,
       );
@@ -271,7 +283,7 @@ describe("beads integration", () => {
     });
 
     it("updates multiple fields at once", async () => {
-      const result = await beads_update.execute(
+      const result = await hive_update.execute(
         {
           id: testBeadId,
           status: "blocked",
@@ -289,7 +301,7 @@ describe("beads integration", () => {
 
     it("throws BeadError for invalid bead ID", async () => {
       await expect(
-        beads_update.execute(
+        hive_update.execute(
           { id: "nonexistent-bead-xyz", status: "closed" },
           mockContext,
         ),
@@ -297,17 +309,17 @@ describe("beads integration", () => {
     });
   });
 
-  describe("beads_close", () => {
+  describe("hive_close", () => {
     it("closes a bead with reason", async () => {
       // Create a fresh bead to close
-      const createResult = await beads_create.execute(
+      const createResult = await hive_create.execute(
         { title: "Bead to close" },
         mockContext,
       );
       const created = parseResponse<Bead>(createResult);
       // Don't add to cleanup since we're closing it
 
-      const result = await beads_close.execute(
+      const result = await hive_close.execute(
         { id: created.id, reason: "Task completed successfully" },
         mockContext,
       );
@@ -316,14 +328,14 @@ describe("beads integration", () => {
       expect(result).toContain(created.id);
 
       // Verify it's actually closed using adapter
-      const closedBead = await adapter.getBead(TEST_PROJECT_KEY, created.id);
+      const closedBead = await adapter.getCell(TEST_PROJECT_KEY, created.id);
       expect(closedBead).toBeDefined();
       expect(closedBead!.status).toBe("closed");
     });
 
     it("throws BeadError for invalid bead ID", async () => {
       await expect(
-        beads_close.execute(
+        hive_close.execute(
           { id: "nonexistent-bead-xyz", reason: "Test" },
           mockContext,
         ),
@@ -331,10 +343,10 @@ describe("beads integration", () => {
     });
   });
 
-  describe("beads_start", () => {
+  describe("hive_start", () => {
     it("marks a bead as in_progress", async () => {
       // Create a fresh bead
-      const createResult = await beads_create.execute(
+      const createResult = await hive_create.execute(
         { title: "Bead to start" },
         mockContext,
       );
@@ -343,35 +355,35 @@ describe("beads integration", () => {
 
       expect(created.status).toBe("open");
 
-      const result = await beads_start.execute({ id: created.id }, mockContext);
+      const result = await hive_start.execute({ id: created.id }, mockContext);
 
       expect(result).toContain("Started");
       expect(result).toContain(created.id);
 
       // Verify status changed using adapter
-      const startedBead = await adapter.getBead(TEST_PROJECT_KEY, created.id);
+      const startedBead = await adapter.getCell(TEST_PROJECT_KEY, created.id);
       expect(startedBead).toBeDefined();
       expect(startedBead!.status).toBe("in_progress");
     });
 
     it("throws BeadError for invalid bead ID", async () => {
       await expect(
-        beads_start.execute({ id: "nonexistent-bead-xyz" }, mockContext),
+        hive_start.execute({ id: "nonexistent-bead-xyz" }, mockContext),
       ).rejects.toThrow(BeadError);
     });
   });
 
-  describe("beads_ready", () => {
+  describe("hive_ready", () => {
     it("returns the highest priority unblocked bead", async () => {
       // Create a high priority bead
-      const createResult = await beads_create.execute(
+      const createResult = await hive_create.execute(
         { title: "High priority ready bead", priority: 0 },
         mockContext,
       );
       const created = parseResponse<Bead>(createResult);
       createdBeadIds.push(created.id);
 
-      const result = await beads_ready.execute({}, mockContext);
+      const result = await hive_ready.execute({}, mockContext);
 
       // Should return a bead (or "No ready beads" message)
       if (result !== "No ready beads") {
@@ -385,7 +397,7 @@ describe("beads integration", () => {
     it("returns no ready beads message when all are closed", async () => {
       // This test depends on the state of the beads database
       // It may return a bead if there are open ones
-      const result = await beads_ready.execute({}, mockContext);
+      const result = await hive_ready.execute({}, mockContext);
 
       expect(typeof result).toBe("string");
       // Either a JSON bead or "No ready beads"
@@ -398,9 +410,9 @@ describe("beads integration", () => {
     });
   });
 
-  describe("beads_create_epic", () => {
+  describe("hive_create_epic", () => {
     it("creates an epic with subtasks", async () => {
-      const result = await beads_create_epic.execute(
+      const result = await hive_create_epic.execute(
         {
           epic_title: "Integration test epic",
           epic_description: "Testing epic creation",
@@ -427,14 +439,14 @@ describe("beads integration", () => {
       // Subtasks should have parent_id pointing to epic
       // Verify via adapter since parent_id may not be in the output schema
       for (const subtask of epicResult.subtasks) {
-        const subtaskBead = await adapter.getBead(TEST_PROJECT_KEY, subtask.id);
+        const subtaskBead = await adapter.getCell(TEST_PROJECT_KEY, subtask.id);
         expect(subtaskBead).toBeDefined();
         expect(subtaskBead!.parent_id).toBe(epicResult.epic.id);
       }
     });
 
     it("creates an epic with files metadata in subtasks", async () => {
-      const result = await beads_create_epic.execute(
+      const result = await hive_create_epic.execute(
         {
           epic_title: "Epic with file references",
           subtasks: [
@@ -460,7 +472,7 @@ describe("beads integration", () => {
     });
 
     it("creates epic with single subtask", async () => {
-      const result = await beads_create_epic.execute(
+      const result = await hive_create_epic.execute(
         {
           epic_title: "Single subtask epic",
           subtasks: [{ title: "Only task", priority: 1 }],
@@ -478,7 +490,7 @@ describe("beads integration", () => {
 
     it("preserves subtask order", async () => {
       const titles = ["First", "Second", "Third", "Fourth"];
-      const result = await beads_create_epic.execute(
+      const result = await hive_create_epic.execute(
         {
           epic_title: "Ordered subtasks epic",
           subtasks: titles.map((title, i) => ({ title, priority: 2 })),
@@ -504,7 +516,7 @@ describe("beads integration", () => {
     let testBeadId: string;
 
     beforeEach(async () => {
-      const result = await beads_create.execute(
+      const result = await hive_create.execute(
         { title: "Thread link test bead" },
         mockContext,
       );
@@ -516,7 +528,7 @@ describe("beads integration", () => {
     it("links a bead to an Agent Mail thread", async () => {
       const threadId = "test-thread-123";
       const result = await beads_link_thread.execute(
-        { bead_id: testBeadId, thread_id: threadId },
+        { cell_id: testBeadId, thread_id: threadId },
         mockContext,
       );
 
@@ -525,7 +537,7 @@ describe("beads integration", () => {
       expect(result).toContain(threadId);
 
       // Verify the thread marker is in the description using adapter
-      const linkedBead = await adapter.getBead(TEST_PROJECT_KEY, testBeadId);
+      const linkedBead = await adapter.getCell(TEST_PROJECT_KEY, testBeadId);
       expect(linkedBead).toBeDefined();
       expect(linkedBead!.description).toContain(`[thread:${threadId}]`);
     });
@@ -535,13 +547,13 @@ describe("beads integration", () => {
 
       // Link once
       await beads_link_thread.execute(
-        { bead_id: testBeadId, thread_id: threadId },
+        { cell_id: testBeadId, thread_id: threadId },
         mockContext,
       );
 
       // Try to link again
       const result = await beads_link_thread.execute(
-        { bead_id: testBeadId, thread_id: threadId },
+        { cell_id: testBeadId, thread_id: threadId },
         mockContext,
       );
 
@@ -550,19 +562,19 @@ describe("beads integration", () => {
 
     it("preserves existing description when linking", async () => {
       // Update bead with a description first
-      await beads_update.execute(
+      await hive_update.execute(
         { id: testBeadId, description: "Important context here" },
         mockContext,
       );
 
       const threadId = "test-thread-789";
       await beads_link_thread.execute(
-        { bead_id: testBeadId, thread_id: threadId },
+        { cell_id: testBeadId, thread_id: threadId },
         mockContext,
       );
 
       // Verify both original description and thread marker exist using adapter
-      const linkedBead = await adapter.getBead(TEST_PROJECT_KEY, testBeadId);
+      const linkedBead = await adapter.getCell(TEST_PROJECT_KEY, testBeadId);
       expect(linkedBead).toBeDefined();
       expect(linkedBead!.description).toContain("Important context here");
       expect(linkedBead!.description).toContain(`[thread:${threadId}]`);
@@ -571,7 +583,7 @@ describe("beads integration", () => {
     it("throws BeadError for invalid bead ID", async () => {
       await expect(
         beads_link_thread.execute(
-          { bead_id: "nonexistent-bead-xyz", thread_id: "thread-123" },
+          { cell_id: "nonexistent-bead-xyz", thread_id: "thread-123" },
           mockContext,
         ),
       ).rejects.toThrow(BeadError);
@@ -581,14 +593,14 @@ describe("beads integration", () => {
   describe("error handling", () => {
     it("throws BeadError with command info on adapter failure", async () => {
       try {
-        await beads_update.execute(
+        await hive_update.execute(
           { id: "definitely-not-a-real-bead-id", status: "closed" },
           mockContext,
         );
         expect.fail("Should have thrown");
       } catch (error) {
         expect(error).toBeInstanceOf(BeadError);
-        const beadError = error as BeadError;
+        const beadError = error as InstanceType<typeof BeadError>;
         expect(beadError.command).toBeDefined();
       }
     });
@@ -597,7 +609,7 @@ describe("beads integration", () => {
   describe("workflow integration", () => {
     it("complete bead lifecycle: create -> start -> update -> close", async () => {
       // 1. Create
-      const createResult = await beads_create.execute(
+      const createResult = await hive_create.execute(
         { title: "Lifecycle test bead", type: "task", priority: 2 },
         mockContext,
       );
@@ -605,14 +617,14 @@ describe("beads integration", () => {
       expect(bead.status).toBe("open");
 
       // 2. Start (in_progress)
-      const startResult = await beads_start.execute(
+      const startResult = await hive_start.execute(
         { id: bead.id },
         mockContext,
       );
       expect(startResult).toContain("Started");
 
       // 3. Update (add progress note)
-      const updateResult = await beads_update.execute(
+      const updateResult = await hive_update.execute(
         { id: bead.id, description: "50% complete" },
         mockContext,
       );
@@ -620,21 +632,21 @@ describe("beads integration", () => {
       expect(updated.description).toContain("50%");
 
       // 4. Close
-      const closeResult = await beads_close.execute(
+      const closeResult = await hive_close.execute(
         { id: bead.id, reason: "Completed successfully" },
         mockContext,
       );
       expect(closeResult).toContain("Closed");
 
       // Verify final state using adapter
-      const finalBead = await adapter.getBead(TEST_PROJECT_KEY, bead.id);
+      const finalBead = await adapter.getCell(TEST_PROJECT_KEY, bead.id);
       expect(finalBead).toBeDefined();
       expect(finalBead!.status).toBe("closed");
     });
 
     it("epic workflow: create epic -> start subtasks -> close subtasks -> close epic", async () => {
       // 1. Create epic with subtasks
-      const epicResult = await beads_create_epic.execute(
+      const epicResult = await hive_create_epic.execute(
         {
           epic_title: "Workflow test epic",
           subtasks: [
@@ -648,32 +660,32 @@ describe("beads integration", () => {
       expect(epic.success).toBe(true);
 
       // 2. Start and complete first subtask
-      await beads_start.execute({ id: epic.subtasks[0].id }, mockContext);
-      await beads_close.execute(
+      await hive_start.execute({ id: epic.subtasks[0].id }, mockContext);
+      await hive_close.execute(
         { id: epic.subtasks[0].id, reason: "Step 1 done" },
         mockContext,
       );
 
       // 3. Start and complete second subtask
-      await beads_start.execute({ id: epic.subtasks[1].id }, mockContext);
-      await beads_close.execute(
+      await hive_start.execute({ id: epic.subtasks[1].id }, mockContext);
+      await hive_close.execute(
         { id: epic.subtasks[1].id, reason: "Step 2 done" },
         mockContext,
       );
 
       // 4. Close the epic
-      await beads_close.execute(
+      await hive_close.execute(
         { id: epic.epic.id, reason: "All subtasks completed" },
         mockContext,
       );
 
       // Verify all are closed using adapter
-      const epicClosed = await adapter.getBead(TEST_PROJECT_KEY, epic.epic.id);
+      const epicClosed = await adapter.getCell(TEST_PROJECT_KEY, epic.epic.id);
       expect(epicClosed).toBeDefined();
       expect(epicClosed!.status).toBe("closed");
 
       for (const subtask of epic.subtasks) {
-        const subtaskClosed = await adapter.getBead(TEST_PROJECT_KEY, subtask.id);
+        const subtaskClosed = await adapter.getCell(TEST_PROJECT_KEY, subtask.id);
         expect(subtaskClosed).toBeDefined();
         expect(subtaskClosed!.status).toBe("closed");
       }