opencode-swarm-plugin 0.33.0 → 0.35.0

package/src/compaction-hook.test.ts

@@ -2,13 +2,32 @@
  * Tests for Swarm-Aware Compaction Hook
  */
 
-import { describe, expect, it, mock } from "bun:test";
+import { describe, expect, it, mock, beforeEach } from "bun:test";
 import {
   SWARM_COMPACTION_CONTEXT,
   SWARM_DETECTION_FALLBACK,
   createCompactionHook,
 } from "./compaction-hook";
 
+// Track log calls for verification
+let logCalls: Array<{ level: string; data: any; message?: string }> = [];
+
+// Mock logger factory
+const createMockLogger = () => ({
+  info: (data: any, message?: string) => {
+    logCalls.push({ level: "info", data, message });
+  },
+  debug: (data: any, message?: string) => {
+    logCalls.push({ level: "debug", data, message });
+  },
+  warn: (data: any, message?: string) => {
+    logCalls.push({ level: "warn", data, message });
+  },
+  error: (data: any, message?: string) => {
+    logCalls.push({ level: "error", data, message });
+  },
+});
+
 // Mock the dependencies
 mock.module("./hive", () => ({
   getHiveWorkingDirectory: () => "/test/project",
@@ -30,7 +49,16 @@ mock.module("swarm-mail", () => ({
   }),
 }));
 
+// Mock logger module
+mock.module("./logger", () => ({
+  createChildLogger: () => createMockLogger(),
+}));
+
 describe("Compaction Hook", () => {
+  beforeEach(() => {
+    // Reset log calls before each test
+    logCalls = [];
+  });
   describe("SWARM_COMPACTION_CONTEXT", () => {
     it("contains coordinator instructions", () => {
       expect(SWARM_COMPACTION_CONTEXT).toContain("COORDINATOR");
@@ -107,4 +135,614 @@ describe("Compaction Hook", () => {
       expect(SWARM_DETECTION_FALLBACK).toContain("Check Your Context");
     });
   });
+
+  describe("Specific swarm state injection (TDD red phase)", () => {
+    it("includes specific epic ID when in_progress epic exists", async () => {
+      // Mock hive with an in_progress epic
+      mock.module("./hive", () => ({
+        getHiveWorkingDirectory: () => "/test/project",
+        getHiveAdapter: async () => ({
+          queryCells: async () => [
+            {
+              id: "bd-epic-123",
+              title: "Add authentication system",
+              type: "epic",
+              status: "in_progress",
+              parent_id: null,
+              updated_at: Date.now(),
+            },
+          ],
+        }),
+      }));
+
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session" };
+      const output = { context: [] as string[] };
+
+      await hook(input, output);
+
+      // Should inject context with the SPECIFIC epic ID, not a placeholder
+      expect(output.context.length).toBeGreaterThan(0);
+      const injectedContext = output.context[0];
+      expect(injectedContext).toContain("bd-epic-123");
+      expect(injectedContext).toContain("Add authentication system");
+    });
+
+    it("includes subtask status summary in injected context", async () => {
+      // Mock hive with epic + subtasks in various states
+      mock.module("./hive", () => ({
+        getHiveWorkingDirectory: () => "/test/project",
+        getHiveAdapter: async () => ({
+          queryCells: async () => [
+            {
+              id: "bd-epic-456",
+              title: "Refactor auth flow",
+              type: "epic",
+              status: "in_progress",
+              parent_id: null,
+              updated_at: Date.now(),
+            },
+            {
+              id: "bd-epic-456.1",
+              title: "Update schema",
+              type: "task",
+              status: "closed",
+              parent_id: "bd-epic-456",
+              updated_at: Date.now(),
+            },
+            {
+              id: "bd-epic-456.2",
+              title: "Implement service layer",
+              type: "task",
+              status: "in_progress",
+              parent_id: "bd-epic-456",
+              updated_at: Date.now(),
+            },
+            {
+              id: "bd-epic-456.3",
+              title: "Add tests",
+              type: "task",
+              status: "open",
+              parent_id: "bd-epic-456",
+              updated_at: Date.now(),
+            },
+          ],
+        }),
+      }));
+
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session" };
+      const output = { context: [] as string[] };
+
+      await hook(input, output);
+
+      expect(output.context.length).toBeGreaterThan(0);
+      const injectedContext = output.context[0];
+      
+      // Should show subtask counts: 1 closed, 1 in_progress, 1 open
+      expect(injectedContext).toMatch(/1.*closed/i);
+      expect(injectedContext).toMatch(/1.*in_progress/i);
+      expect(injectedContext).toMatch(/1.*open/i);
+    });
+
+    it("includes project path in context", async () => {
+      mock.module("./hive", () => ({
+        getHiveWorkingDirectory: () => "/Users/joel/test-project",
+        getHiveAdapter: async () => ({
+          queryCells: async () => [
+            {
+              id: "bd-epic-789",
+              title: "Feature work",
+              type: "epic",
+              status: "in_progress",
+              parent_id: null,
+              updated_at: Date.now(),
+            },
+          ],
+        }),
+      }));
+
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session" };
+      const output = { context: [] as string[] };
+
+      await hook(input, output);
+
+      expect(output.context.length).toBeGreaterThan(0);
+      const injectedContext = output.context[0];
+      
+      // Should include the actual project path, not a placeholder
+      expect(injectedContext).toContain("/Users/joel/test-project");
+    });
+
+    it("includes actionable swarm_status call with epic ID", async () => {
+      mock.module("./hive", () => ({
+        getHiveWorkingDirectory: () => "/test/project",
+        getHiveAdapter: async () => ({
+          queryCells: async () => [
+            {
+              id: "bd-epic-999",
+              title: "Critical fix",
+              type: "epic",
+              status: "in_progress",
+              parent_id: null,
+              updated_at: Date.now(),
+            },
+          ],
+        }),
+      }));
+
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session" };
+      const output = { context: [] as string[] };
+
+      await hook(input, output);
+
+      expect(output.context.length).toBeGreaterThan(0);
+      const injectedContext = output.context[0];
+      
+      // Should include actionable swarm_status call with the SPECIFIC epic ID
+      expect(injectedContext).toContain('swarm_status(epic_id="bd-epic-999"');
+      expect(injectedContext).toContain('project_key="/test/project"');
+    });
+
+    it("includes coordinator role reminder - NOT worker commands", async () => {
+      // Mock an in-progress epic with subtasks
+      mock.module("./hive", () => ({
+        getHiveWorkingDirectory: () => "/test/project",
+        getHiveAdapter: async () => ({
+          queryCells: async () => [
+            {
+              id: "bd-epic-123",
+              title: "Test Epic",
+              type: "epic",
+              status: "in_progress",
+              parent_id: null,
+              updated_at: Date.now(),
+            },
+            {
+              id: "bd-task-1",
+              type: "task",
+              status: "open",
+              parent_id: "bd-epic-123",
+              updated_at: Date.now(),
+            },
+          ],
+        }),
+      }));
+
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session" };
+      const output = { context: [] as string[] };
+
+      await hook(input, output);
+
+      expect(output.context.length).toBeGreaterThan(0);
+      const injectedContext = output.context[0];
+      
+      // Should remind coordinator of their ROLE
+      expect(injectedContext).toContain("YOU ARE THE COORDINATOR");
+      expect(injectedContext).toContain("Spawn workers");
+      
+      // Should include coordinator commands
+      expect(injectedContext).toContain("swarm_spawn_subtask");
+      expect(injectedContext).toContain("swarm_review");
+    });
+  });
+
+  describe("scanSessionMessages", () => {
+    it("returns empty state when client is undefined", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      const result = await scanSessionMessages(undefined, "session-123");
+      
+      expect(result.epicId).toBeUndefined();
+      expect(result.epicTitle).toBeUndefined();
+      expect(result.projectPath).toBeUndefined();
+      expect(result.agentName).toBeUndefined();
+      expect(result.subtasks.size).toBe(0);
+      expect(result.lastAction).toBeUndefined();
+    });
+
+    it("extracts epic data from hive_create_epic tool call", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      // Mock SDK client
+      const mockClient = {
+        session: {
+          messages: async ({ sessionID, limit }: { sessionID: string; limit?: number }) => {
+            return [
+              {
+                info: { id: "msg-1", sessionID: "session-123" },
+                parts: [
+                  {
+                    id: "part-1",
+                    sessionID: "session-123",
+                    messageID: "msg-1",
+                    type: "tool" as const,
+                    callID: "call-1",
+                    tool: "hive_create_epic",
+                    state: {
+                      status: "completed" as const,
+                      input: {
+                        epic_title: "Add authentication system",
+                        epic_description: "Implement OAuth flow",
+                      },
+                      output: JSON.stringify({
+                        success: true,
+                        epic: { id: "bd-epic-123" },
+                      }),
+                      title: "Create Epic",
+                      metadata: {},
+                      time: { start: Date.now(), end: Date.now() },
+                    },
+                  },
+                ],
+              },
+            ];
+          },
+        },
+      } as any;
+      
+      const result = await scanSessionMessages(mockClient, "session-123");
+      
+      expect(result.epicId).toBe("bd-epic-123");
+      expect(result.epicTitle).toBe("Add authentication system");
+    });
+
+    it("extracts agent name from swarmmail_init tool call", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      const mockClient = {
+        session: {
+          messages: async () => [
+            {
+              info: { id: "msg-1", sessionID: "session-123" },
+              parts: [
+                {
+                  id: "part-1",
+                  sessionID: "session-123",
+                  messageID: "msg-1",
+                  type: "tool" as const,
+                  callID: "call-1",
+                  tool: "swarmmail_init",
+                  state: {
+                    status: "completed" as const,
+                    input: {
+                      project_path: "/test/project",
+                      task_description: "Working on auth",
+                    },
+                    output: JSON.stringify({
+                      agent_name: "BlueLake",
+                      project_key: "/test/project",
+                    }),
+                    title: "Init Swarm Mail",
+                    metadata: {},
+                    time: { start: Date.now(), end: Date.now() },
+                  },
+                },
+              ],
+            },
+          ],
+        },
+      } as any;
+      
+      const result = await scanSessionMessages(mockClient, "session-123");
+      
+      expect(result.agentName).toBe("BlueLake");
+      expect(result.projectPath).toBe("/test/project");
+    });
+
+    it("extracts subtask data from swarm_spawn_subtask tool call", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      const mockClient = {
+        session: {
+          messages: async () => [
+            {
+              info: { id: "msg-1", sessionID: "session-123" },
+              parts: [
+                {
+                  id: "part-1",
+                  sessionID: "session-123",
+                  messageID: "msg-1",
+                  type: "tool" as const,
+                  callID: "call-1",
+                  tool: "swarm_spawn_subtask",
+                  state: {
+                    status: "completed" as const,
+                    input: {
+                      bead_id: "bd-task-1",
+                      epic_id: "bd-epic-123",
+                      subtask_title: "Implement OAuth service",
+                      files: ["src/auth/oauth.ts"],
+                    },
+                    output: JSON.stringify({
+                      worker: "RedMountain",
+                      bead_id: "bd-task-1",
+                    }),
+                    title: "Spawn Subtask",
+                    metadata: {},
+                    time: { start: Date.now(), end: Date.now() },
+                  },
+                },
+              ],
+            },
+          ],
+        },
+      } as any;
+      
+      const result = await scanSessionMessages(mockClient, "session-123");
+      
+      expect(result.subtasks.size).toBe(1);
+      expect(result.subtasks.get("bd-task-1")).toEqual({
+        title: "Implement OAuth service",
+        status: "spawned",
+        worker: "RedMountain",
+        files: ["src/auth/oauth.ts"],
+      });
+    });
+
+    it("marks subtask as completed from swarm_complete tool call", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      const mockClient = {
+        session: {
+          messages: async () => [
+            {
+              info: { id: "msg-1", sessionID: "session-123" },
+              parts: [
+                {
+                  id: "part-1",
+                  sessionID: "session-123",
+                  messageID: "msg-1",
+                  type: "tool" as const,
+                  callID: "call-1",
+                  tool: "swarm_spawn_subtask",
+                  state: {
+                    status: "completed" as const,
+                    input: {
+                      bead_id: "bd-task-1",
+                      epic_id: "bd-epic-123",
+                      subtask_title: "Fix bug",
+                      files: [],
+                    },
+                    output: "{}",
+                    title: "Spawn",
+                    metadata: {},
+                    time: { start: 100, end: 200 },
+                  },
+                },
+                {
+                  id: "part-2",
+                  sessionID: "session-123",
+                  messageID: "msg-1",
+                  type: "tool" as const,
+                  callID: "call-2",
+                  tool: "swarm_complete",
+                  state: {
+                    status: "completed" as const,
+                    input: {
+                      bead_id: "bd-task-1",
+                      summary: "Fixed the bug",
+                    },
+                    output: JSON.stringify({ success: true, closed: true }),
+                    title: "Complete",
+                    metadata: {},
+                    time: { start: 300, end: 400 },
+                  },
+                },
+              ],
+            },
+          ],
+        },
+      } as any;
+      
+      const result = await scanSessionMessages(mockClient, "session-123");
+      
+      expect(result.subtasks.get("bd-task-1")?.status).toBe("completed");
+    });
+
+    it("captures last action timestamp", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      const mockClient = {
+        session: {
+          messages: async () => [
+            {
+              info: { id: "msg-1", sessionID: "session-123" },
+              parts: [
+                {
+                  id: "part-1",
+                  sessionID: "session-123",
+                  messageID: "msg-1",
+                  type: "tool" as const,
+                  callID: "call-1",
+                  tool: "swarm_status",
+                  state: {
+                    status: "completed" as const,
+                    input: {
+                      epic_id: "bd-epic-123",
+                      project_key: "/test",
+                    },
+                    output: "{}",
+                    title: "Check Status",
+                    metadata: {},
+                    time: { start: 1000, end: 2000 },
+                  },
+                },
+              ],
+            },
+          ],
+        },
+      } as any;
+      
+      const result = await scanSessionMessages(mockClient, "session-123");
+      
+      expect(result.lastAction).toBeDefined();
+      expect(result.lastAction?.tool).toBe("swarm_status");
+      expect(result.lastAction?.timestamp).toBe(2000);
+    });
+
+    it("respects limit parameter", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      
+      let capturedLimit: number | undefined;
+      const mockClient = {
+        session: {
+          messages: async ({ limit }: { limit?: number }) => {
+            capturedLimit = limit;
+            return [];
+          },
+        },
+      } as any;
+      
+      await scanSessionMessages(mockClient, "session-123", 50);
+      
+      expect(capturedLimit).toBe(50);
+    });
+  });
+
+  describe("Logging instrumentation", () => {
+    it("logs compaction start with session_id", async () => {
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session-123" };
+      const output = { context: [] as string[] };
+
+      await hook(input, output);
+
+      const startLog = logCalls.find(
+        (log) => log.level === "info" && log.message === "compaction started",
+      );
+      expect(startLog).toBeDefined();
+      expect(startLog?.data).toHaveProperty("session_id", "test-session-123");
+    });
+
+    it("logs detection phase with confidence and reasons", async () => {
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session" };
+      const output = { context: [] as string[] };
+
+      await hook(input, output);
+
+      const detectionLog = logCalls.find(
+        (log) =>
+          log.level === "debug" && log.message === "swarm detection complete",
+      );
+      expect(detectionLog).toBeDefined();
+      expect(detectionLog?.data).toHaveProperty("confidence");
+      expect(detectionLog?.data).toHaveProperty("detected");
+      expect(detectionLog?.data).toHaveProperty("reason_count");
+    });
+
+    it("logs context injection when swarm detected", async () => {
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session" };
+      const output = { context: [] as string[] };
+
+      // Mock detection to return medium confidence
+      mock.module("./hive", () => ({
+        getHiveWorkingDirectory: () => "/test/project",
+        getHiveAdapter: async () => ({
+          queryCells: async () => [
+            {
+              id: "bd-123",
+              type: "epic",
+              status: "open",
+              parent_id: null,
+              updated_at: Date.now(),
+            },
+          ],
+        }),
+      }));
+
+      await hook(input, output);
+
+      const injectionLog = logCalls.find(
+        (log) =>
+          log.level === "info" && log.message === "injected swarm context",
+      );
+      expect(injectionLog).toBeDefined();
+      expect(injectionLog?.data).toHaveProperty("confidence");
+      expect(injectionLog?.data).toHaveProperty("context_length");
+    });
+
+    it("logs completion with duration and success", async () => {
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session" };
+      const output = { context: [] as string[] };
+
+      await hook(input, output);
+
+      const completeLog = logCalls.find(
+        (log) => log.level === "info" && log.message === "compaction complete",
+      );
+      expect(completeLog).toBeDefined();
+      expect(completeLog?.data).toHaveProperty("duration_ms");
+      expect(completeLog?.data.duration_ms).toBeGreaterThanOrEqual(0);
+      expect(completeLog?.data).toHaveProperty("success", true);
+    });
+
+    it("logs detailed detection sources (hive, swarm-mail)", async () => {
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session" };
+      const output = { context: [] as string[] };
+
+      await hook(input, output);
+
+      // Should log details about checking swarm-mail
+      const swarmMailLog = logCalls.find(
+        (log) => log.level === "debug" && log.message?.includes("swarm-mail"),
+      );
+      // Should log details about checking hive
+      const hiveLog = logCalls.find(
+        (log) => log.level === "debug" && log.message?.includes("hive"),
+      );
+
+      // At least one source should be checked
+      expect(logCalls.length).toBeGreaterThan(0);
+    });
+
+    it("logs errors without throwing when detection fails", async () => {
+      // Mock hive to throw
+      mock.module("./hive", () => ({
+        getHiveWorkingDirectory: () => {
+          throw new Error("Hive not available");
+        },
+        getHiveAdapter: async () => {
+          throw new Error("Hive not available");
+        },
+      }));
+
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session" };
+      const output = { context: [] as string[] };
+
+      // Should not throw
+      await expect(hook(input, output)).resolves.toBeUndefined();
+
+      // Should still complete successfully
+      const completeLog = logCalls.find(
+        (log) => log.level === "info" && log.message === "compaction complete",
+      );
+      expect(completeLog).toBeDefined();
+    });
+
+    it("includes context size when injecting", async () => {
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session" };
+      const output = { context: [] as string[] };
+
+      await hook(input, output);
+
+      // If context was injected, should log the size
+      if (output.context.length > 0) {
+        const injectionLog = logCalls.find(
+          (log) =>
+            log.level === "info" && log.message === "injected swarm context",
+        );
+        expect(injectionLog?.data.context_length).toBeGreaterThan(0);
+      }
+    });
+  });
 });