opencode-swarm-plugin 0.30.7 → 0.31.1

package/src/hive.integration.test.ts

@@ -406,7 +406,7 @@ describe("beads integration", () => {
   });
 
   describe("hive_create_epic", () => {
-    it("creates an epic with subtasks", async () => {
+    it("creates an epic with subtasks and syncs to JSONL", async () => {
       const result = await hive_create_epic.execute(
         {
           epic_title: "Integration test epic",
@@ -438,6 +438,28 @@ describe("beads integration", () => {
         expect(subtaskBead).toBeDefined();
         expect(subtaskBead!.parent_id).toBe(epicResult.epic.id);
       }
+      
+      // NEW TEST: Verify cells are synced to JSONL immediately
+      const { readFileSync, existsSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const jsonlPath = join(TEST_PROJECT_KEY, ".hive", "issues.jsonl");
+      
+      expect(existsSync(jsonlPath)).toBe(true);
+      
+      const jsonlContent = readFileSync(jsonlPath, "utf-8");
+      const lines = jsonlContent.trim().split("\n").filter(l => l);
+      const cells = lines.map(line => JSON.parse(line));
+      
+      // Epic and all subtasks should be in JSONL
+      const epicInJsonl = cells.find(c => c.id === epicResult.epic.id);
+      expect(epicInJsonl).toBeDefined();
+      expect(epicInJsonl!.title).toBe("Integration test epic");
+      
+      for (const subtask of epicResult.subtasks) {
+        const subtaskInJsonl = cells.find(c => c.id === subtask.id);
+        expect(subtaskInJsonl).toBeDefined();
+        expect(subtaskInJsonl!.parent_id).toBe(epicResult.epic.id);
+      }
     });
 
     it("creates an epic with files metadata in subtasks", async () => {
@@ -601,6 +623,181 @@ describe("beads integration", () => {
     });
   });
 
+  describe("partial ID resolution", () => {
+    let fullId: string;
+    let hash: string;
+
+    beforeEach(async () => {
+      // Create a test cell to resolve
+      const result = await hive_create.execute(
+        { title: "Partial ID test cell" },
+        mockContext,
+      );
+      const cell = parseResponse<Cell>(result);
+      fullId = cell.id;
+      createdBeadIds.push(fullId);
+
+      // Extract hash from ID (format: {prefix}-{hash}-{timestamp}{random})
+      // The last segment is always timestamp+random (11 chars)
+      // The hash is the 6-char segment before that
+      // Examples:
+      //   "opencode-swarm-monorepo-lf2p4u-mjd2h5v4wdt" -> hash is "lf2p4u"
+      //   "cell--gcel4-mjd2h5v4wdt" -> hash is "-gcel4" (negative hash creates consecutive hyphens)
+      
+      // Find the last hyphen, then work backwards to find the second-to-last hyphen
+      const lastHyphenIndex = fullId.lastIndexOf("-");
+      if (lastHyphenIndex === -1) {
+        hash = "";
+      } else {
+        // Get everything before the last hyphen
+        const beforeLast = fullId.substring(0, lastHyphenIndex);
+        // Find the second-to-last hyphen
+        const secondLastHyphenIndex = beforeLast.lastIndexOf("-");
+        if (secondLastHyphenIndex === -1) {
+          hash = "";
+        } else {
+          // Hash is between second-to-last and last hyphen
+          hash = fullId.substring(secondLastHyphenIndex + 1, lastHyphenIndex);
+        }
+      }
+    });
+
+    describe("hive_update", () => {
+      it("accepts full cell ID (no resolution needed)", async () => {
+        const result = await hive_update.execute(
+          { id: fullId, description: "Updated via full ID" },
+          mockContext,
+        );
+
+        const updated = parseResponse<Cell>(result);
+        expect(updated.id).toBe(fullId);
+        expect(updated.description).toContain("Updated via full ID");
+      });
+
+      it("resolves hash to full ID (or shows helpful error if ambiguous)", async () => {
+        try {
+          const result = await hive_update.execute(
+            { id: hash, priority: 1 },
+            mockContext,
+          );
+
+          const updated = parseResponse<Cell>(result);
+          expect(updated.id).toBe(fullId);
+          expect(updated.priority).toBe(1);
+        } catch (error) {
+          // In test environment with many cells, hash may be ambiguous
+          // Verify we get a helpful error message
+          if (error instanceof Error && error.message.includes("Ambiguous")) {
+            expect(error.message).toMatch(/ambiguous.*multiple/i);
+            expect(error.message).toContain(hash);
+          } else {
+            throw error; // Re-throw if not ambiguity error
+          }
+        }
+      });
+
+      it("throws helpful error for non-existent hash", async () => {
+        await expect(
+          hive_update.execute({ id: "zzzzzz", status: "closed" }, mockContext),
+        ).rejects.toThrow(/not found|no cell|zzzzzz/i);
+      });
+
+      it("throws helpful error for ambiguous hash", async () => {
+        // Create another cell with potentially similar hash
+        // (in practice, hashes are unique, but we simulate ambiguity by using a short partial)
+        // This test verifies the error message is helpful
+        try {
+          // Use a single char which might match multiple cells in larger datasets
+          await hive_update.execute({ id: "a", status: "closed" }, mockContext);
+          // If it succeeds, it means only one cell matched - that's fine
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          // Error should mention ambiguity if multiple matches
+          if (message.includes("ambiguous") || message.includes("multiple")) {
+            expect(message).toMatch(/ambiguous|multiple/i);
+          }
+        }
+      });
+    });
+
+    describe("hive_close", () => {
+      it("accepts full cell ID", async () => {
+        const result = await hive_close.execute(
+          { id: fullId, reason: "Closed via full ID" },
+          mockContext,
+        );
+
+        expect(result).toContain("Closed");
+        expect(result).toContain(fullId);
+
+        const closed = await adapter.getCell(TEST_PROJECT_KEY, fullId);
+        expect(closed?.status).toBe("closed");
+      });
+
+      it("resolves hash to full ID (or shows helpful error if ambiguous)", async () => {
+        try {
+          const result = await hive_close.execute(
+            { id: hash, reason: "Close via hash" },
+            mockContext,
+          );
+
+          expect(result).toContain("Closed");
+          expect(result).toContain(fullId);
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("Ambiguous")) {
+            expect(error.message).toMatch(/ambiguous.*multiple/i);
+            expect(error.message).toContain(hash);
+          } else {
+            throw error;
+          }
+        }
+      });
+
+      it("throws helpful error for non-existent hash", async () => {
+        await expect(
+          hive_close.execute({ id: "nonono", reason: "Test" }, mockContext),
+        ).rejects.toThrow(/not found|no cell|nonono/i);
+      });
+    });
+
+    describe("hive_start", () => {
+      it("accepts full cell ID", async () => {
+        const result = await hive_start.execute({ id: fullId }, mockContext);
+
+        expect(result).toContain("Started");
+        expect(result).toContain(fullId);
+
+        const started = await adapter.getCell(TEST_PROJECT_KEY, fullId);
+        expect(started?.status).toBe("in_progress");
+      });
+
+      it("resolves hash to full ID (or shows helpful error if ambiguous)", async () => {
+        try {
+          const result = await hive_start.execute(
+            { id: hash },
+            mockContext,
+          );
+
+          expect(result).toContain("Started");
+          expect(result).toContain(fullId);
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("Ambiguous")) {
+            expect(error.message).toMatch(/ambiguous.*multiple/i);
+            expect(error.message).toContain(hash);
+          } else {
+            throw error;
+          }
+        }
+      });
+
+      it("throws helpful error for non-existent hash", async () => {
+        await expect(
+          hive_start.execute({ id: "nope99" }, mockContext),
+        ).rejects.toThrow(/not found|no cell|nope99/i);
+      });
+    });
+  });
+
   describe("workflow integration", () => {
     it("complete bead lifecycle: create -> start -> update -> close", async () => {
       // 1. Create
@@ -1225,8 +1422,8 @@ describe("beads integration", () => {
           mockContext,
         );
 
-        // Should return "No cells to sync" since no dirty cells
-        expect(result).toContain("No cells to sync");
+        // Should return "No cells or memories to sync" since no dirty cells
+        expect(result).toContain("No cells or memories to sync");
       } finally {
         setHiveWorkingDirectory(originalDir);
         rmSync(tempProject, { recursive: true, force: true });
@@ -1450,4 +1647,227 @@ describe("beads integration", () => {
       rmSync(tempProject, { recursive: true, force: true });
     });
   });
+
+  describe("process exit hook", () => {
+    it("registers beforeExit hook that syncs dirty cells", async () => {
+      const { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+      const { execSync } = await import("node:child_process");
+
+      // Create temp project
+      const tempProject = join(tmpdir(), `hive-exit-hook-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+
+      // Initialize git repo
+      execSync("git init", { cwd: tempProject });
+      execSync('git config user.email "test@example.com"', { cwd: tempProject });
+      execSync('git config user.name "Test User"', { cwd: tempProject });
+
+      // Initial commit with empty issues.jsonl
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+      execSync("git add .", { cwd: tempProject });
+      execSync('git commit -m "initial"', { cwd: tempProject });
+
+      // Set working directory
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create a cell (marks it dirty but don't sync)
+        await hive_create.execute(
+          { title: "Exit hook test cell", type: "task" },
+          mockContext,
+        );
+
+        // Verify cell is NOT in JSONL yet (only in PGLite)
+        const beforeContent = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+        expect(beforeContent.trim()).toBe("");
+
+        // Simulate process exit by triggering beforeExit event
+        process.emit("beforeExit", 0);
+
+        // Wait for async flush to complete
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        // Verify cell was synced to JSONL by the exit hook
+        const afterContent = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+        expect(afterContent.trim()).not.toBe("");
+
+        const cells = afterContent.trim().split("\n").map(line => JSON.parse(line));
+        expect(cells).toHaveLength(1);
+        expect(cells[0].title).toBe("Exit hook test cell");
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+
+    it("exit hook is idempotent - safe to call multiple times", async () => {
+      const { mkdirSync, rmSync, writeFileSync, readFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      // Create temp project
+      const tempProject = join(tmpdir(), `hive-exit-hook-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+
+      // Set working directory
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create a cell
+        await hive_create.execute(
+          { title: "Idempotent test cell", type: "task" },
+          mockContext,
+        );
+
+        // Trigger exit hook multiple times
+        process.emit("beforeExit", 0);
+        await new Promise(resolve => setTimeout(resolve, 50));
+        
+        process.emit("beforeExit", 0);
+        await new Promise(resolve => setTimeout(resolve, 50));
+
+        // Verify cell is written only once (no duplication)
+        const content = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+        const lines = content.trim().split("\n").filter(l => l);
+        
+        // Should have exactly one cell (even though we triggered hook twice)
+        expect(lines.length).toBeGreaterThanOrEqual(1);
+        
+        // All cells should have unique IDs
+        const cells = lines.map(line => JSON.parse(line));
+        const uniqueIds = new Set(cells.map(c => c.id));
+        expect(uniqueIds.size).toBe(cells.length);
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+
+    it("exit hook handles case with no dirty cells gracefully", async () => {
+      const { mkdirSync, rmSync, writeFileSync, readFileSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      // Create temp project with empty JSONL
+      const tempProject = join(tmpdir(), `hive-exit-hook-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+      writeFileSync(join(hiveDir, "issues.jsonl"), "");
+
+      // Set working directory
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Trigger exit hook with no dirty cells (should not throw)
+        process.emit("beforeExit", 0);
+        await new Promise(resolve => setTimeout(resolve, 50));
+
+        // JSONL should still be empty (no error thrown)
+        const content = readFileSync(join(hiveDir, "issues.jsonl"), "utf-8");
+        expect(content.trim()).toBe("");
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe("bigint to Date conversion", () => {
+    it("should handle PGLite bigint timestamps correctly in hive_query", async () => {
+      const { mkdirSync, rmSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      const tempProject = join(tmpdir(), `hive-bigint-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create a cell
+        const createResponse = await hive_create.execute(
+          { title: "Test bigint dates", type: "task" },
+          mockContext
+        );
+        const created = parseResponse<Cell>(createResponse);
+        
+        // Query it back - this triggers formatCellForOutput with PGLite bigint timestamps
+        const queryResponse = await hive_query.execute({ status: "open" }, mockContext);
+        const queried = parseResponse<Cell[]>(queryResponse);
+
+        expect(queried.length).toBeGreaterThan(0);
+        const cell = queried.find(c => c.id === created.id);
+        expect(cell).toBeDefined();
+
+        // These should be valid ISO date strings, not "Invalid Date"
+        expect(cell!.created_at).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+        expect(cell!.updated_at).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+        expect(cell!.created_at).not.toBe("Invalid Date");
+        expect(cell!.updated_at).not.toBe("Invalid Date");
+
+        // Verify dates are actually valid by parsing
+        const createdDate = new Date(cell!.created_at);
+        const updatedDate = new Date(cell!.updated_at);
+        expect(createdDate.getTime()).toBeGreaterThan(0);
+        expect(updatedDate.getTime()).toBeGreaterThan(0);
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+
+    it("should handle closed_at bigint timestamp correctly", async () => {
+      const { mkdirSync, rmSync } = await import("node:fs");
+      const { join } = await import("node:path");
+      const { tmpdir } = await import("node:os");
+
+      const tempProject = join(tmpdir(), `hive-bigint-closed-test-${Date.now()}`);
+      const hiveDir = join(tempProject, ".hive");
+      mkdirSync(hiveDir, { recursive: true });
+
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create and close a cell
+        const createResponse = await hive_create.execute(
+          { title: "Test closed bigint date", type: "task" },
+          mockContext
+        );
+        const created = parseResponse<Cell>(createResponse);
+
+        await hive_close.execute(
+          { id: created.id, reason: "Testing bigint closed_at" },
+          mockContext
+        );
+
+        // Query closed cells
+        const queryResponse = await hive_query.execute({ status: "closed" }, mockContext);
+        const queried = parseResponse<Cell[]>(queryResponse);
+
+        const cell = queried.find(c => c.id === created.id);
+        expect(cell).toBeDefined();
+        expect(cell!.closed_at).toBeDefined();
+        expect(cell!.closed_at).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+        expect(cell!.closed_at).not.toBe("Invalid Date");
+
+        // Verify closed_at is valid
+        const closedDate = new Date(cell!.closed_at!);
+        expect(closedDate.getTime()).toBeGreaterThan(0);
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+  });
 });