opencode-swarm-plugin 0.32.0 → 0.34.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,592 @@ 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 (SDK client integration)", () => {
+    /**
+     * These tests verify that we can extract swarm state from session messages
+     * using the OpenCode SDK client.
+     * 
+     * Key types from @opencode-ai/sdk:
+     * - ToolPart: { type: "tool", tool: string, state: ToolState, ... }
+     * - ToolStateCompleted: { status: "completed", input: Record<string, unknown>, output: string, ... }
+     * - Part: union type including ToolPart
+     * - Message: { id, sessionID, role, ... }
+     * 
+     * SDK API:
+     * - client.session.messages({ sessionID, limit }) → { info: Message, parts: Part[] }[]
+     */
+
+    // Mock SDK client factory
+    const createMockClient = (messages: Array<{ info: any; parts: any[] }>) => ({
+      session: {
+        messages: async ({ sessionID, limit }: { sessionID: string; limit?: number }) => ({
+          data: messages,
+          error: undefined,
+        }),
+      },
+    });
+
+    it("extracts epic ID from swarm_spawn_subtask tool calls", async () => {
+      const mockMessages = [
+        {
+          info: { id: "msg-1", sessionID: "sess-1", role: "assistant" },
+          parts: [
+            {
+              id: "part-1",
+              type: "tool",
+              tool: "swarm_spawn_subtask",
+              state: {
+                status: "completed",
+                input: {
+                  epic_id: "bd-epic-auth-123",
+                  subtask_title: "Implement auth service",
+                  files: ["src/auth/service.ts"],
+                },
+                output: JSON.stringify({ success: true, agent_name: "BlueLake" }),
+                title: "Spawned subtask",
+                metadata: {},
+                time: { start: 1000, end: 2000 },
+              },
+            },
+          ],
+        },
+      ];
+
+      const client = createMockClient(mockMessages);
+      
+      // This function doesn't exist yet - TDD Red phase
+      const { scanSessionMessages } = await import("./compaction-hook");
+      const result = await scanSessionMessages(client as any, "sess-1");
+
+      expect(result.epicId).toBe("bd-epic-auth-123");
+      expect(result.subtasks.size).toBeGreaterThan(0);
+    });
+
+    it("extracts agent name from swarmmail_init tool calls", async () => {
+      const mockMessages = [
+        {
+          info: { id: "msg-1", sessionID: "sess-1", role: "assistant" },
+          parts: [
+            {
+              id: "part-1",
+              type: "tool",
+              tool: "swarmmail_init",
+              state: {
+                status: "completed",
+                input: {
+                  project_path: "/Users/joel/project",
+                  task_description: "Working on auth",
+                },
+                output: JSON.stringify({ 
+                  agent_name: "DarkWind",
+                  project_key: "/Users/joel/project",
+                }),
+                title: "Initialized swarm mail",
+                metadata: {},
+                time: { start: 1000, end: 2000 },
+              },
+            },
+          ],
+        },
+      ];
+
+      const client = createMockClient(mockMessages);
+      const { scanSessionMessages } = await import("./compaction-hook");
+      const result = await scanSessionMessages(client as any, "sess-1");
+
+      expect(result.agentName).toBe("DarkWind");
+      expect(result.projectPath).toBe("/Users/joel/project");
+    });
+
+    it("extracts epic title from hive_create_epic tool calls", async () => {
+      const mockMessages = [
+        {
+          info: { id: "msg-1", sessionID: "sess-1", role: "assistant" },
+          parts: [
+            {
+              id: "part-1",
+              type: "tool",
+              tool: "hive_create_epic",
+              state: {
+                status: "completed",
+                input: {
+                  epic_title: "Add OAuth authentication",
+                  epic_description: "Implement OAuth2 flow",
+                  subtasks: [
+                    { title: "Schema", files: ["src/schema.ts"] },
+                    { title: "Service", files: ["src/service.ts"] },
+                  ],
+                },
+                output: JSON.stringify({ 
+                  epic_id: "bd-epic-oauth-456",
+                  subtask_ids: ["bd-epic-oauth-456.1", "bd-epic-oauth-456.2"],
+                }),
+                title: "Created epic",
+                metadata: {},
+                time: { start: 1000, end: 2000 },
+              },
+            },
+          ],
+        },
+      ];
+
+      const client = createMockClient(mockMessages);
+      const { scanSessionMessages } = await import("./compaction-hook");
+      const result = await scanSessionMessages(client as any, "sess-1");
+
+      expect(result.epicId).toBe("bd-epic-oauth-456");
+      expect(result.epicTitle).toBe("Add OAuth authentication");
+      expect(result.subtasks.size).toBe(2);
+    });
+
+    it("tracks last action with timestamp", async () => {
+      const mockMessages = [
+        {
+          info: { id: "msg-1", sessionID: "sess-1", role: "assistant" },
+          parts: [
+            {
+              id: "part-1",
+              type: "tool",
+              tool: "swarm_status",
+              state: {
+                status: "completed",
+                input: { epic_id: "bd-epic-123", project_key: "/path" },
+                output: JSON.stringify({ status: "in_progress" }),
+                title: "Checked status",
+                metadata: {},
+                time: { start: 5000, end: 6000 },
+              },
+            },
+          ],
+        },
+      ];
+
+      const client = createMockClient(mockMessages);
+      const { scanSessionMessages } = await import("./compaction-hook");
+      const result = await scanSessionMessages(client as any, "sess-1");
+
+      expect(result.lastAction).toBeDefined();
+      expect(result.lastAction?.tool).toBe("swarm_status");
+      expect(result.lastAction?.timestamp).toBe(6000);
+    });
+
+    it("ignores non-tool parts", async () => {
+      const mockMessages = [
+        {
+          info: { id: "msg-1", sessionID: "sess-1", role: "assistant" },
+          parts: [
+            { id: "part-1", type: "text", text: "Hello" },
+            { id: "part-2", type: "reasoning", text: "Thinking..." },
+          ],
+        },
+      ];
+
+      const client = createMockClient(mockMessages);
+      const { scanSessionMessages } = await import("./compaction-hook");
+      const result = await scanSessionMessages(client as any, "sess-1");
+
+      expect(result.epicId).toBeUndefined();
+      expect(result.subtasks.size).toBe(0);
+    });
+
+    it("ignores pending/running tool states", async () => {
+      const mockMessages = [
+        {
+          info: { id: "msg-1", sessionID: "sess-1", role: "assistant" },
+          parts: [
+            {
+              id: "part-1",
+              type: "tool",
+              tool: "swarm_spawn_subtask",
+              state: {
+                status: "pending",
+                input: { epic_id: "bd-epic-123" },
+                raw: "{}",
+              },
+            },
+            {
+              id: "part-2",
+              type: "tool",
+              tool: "swarm_status",
+              state: {
+                status: "running",
+                input: { epic_id: "bd-epic-456" },
+                time: { start: 1000 },
+              },
+            },
+          ],
+        },
+      ];
+
+      const client = createMockClient(mockMessages);
+      const { scanSessionMessages } = await import("./compaction-hook");
+      const result = await scanSessionMessages(client as any, "sess-1");
+
+      // Should not extract from pending/running states
+      expect(result.epicId).toBeUndefined();
+    });
+
+    it("handles SDK client errors gracefully", async () => {
+      const errorClient = {
+        session: {
+          messages: async () => ({
+            data: undefined,
+            error: { message: "Network error" },
+          }),
+        },
+      };
+
+      const { scanSessionMessages } = await import("./compaction-hook");
+      const result = await scanSessionMessages(errorClient as any, "sess-1");
+
+      // Should return empty state, not throw
+      expect(result.subtasks.size).toBe(0);
+      expect(result.epicId).toBeUndefined();
+    });
+
+    it("returns empty state when client is undefined", async () => {
+      const { scanSessionMessages } = await import("./compaction-hook");
+      const result = await scanSessionMessages(undefined as any, "sess-1");
+
+      expect(result.subtasks.size).toBe(0);
+    });
+  });
+
+  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);
+      }
+    });
+  });
 });