opencode-swarm-plugin 0.34.0 → 0.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",

package/src/compaction-hook.test.ts

@@ -7,6 +7,8 @@ import {
   SWARM_COMPACTION_CONTEXT,
   SWARM_DETECTION_FALLBACK,
   createCompactionHook,
+  scanSessionMessages,
+  type ScannedSwarmState,
 } from "./compaction-hook";
 
 // Track log calls for verification
@@ -330,257 +332,6 @@ describe("Compaction Hook", () => {
     });
   });
 
-  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();
@@ -714,13 +465,230 @@ describe("Compaction Hook", () => {
       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);
-      }
+        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);
+        }
+    });
+  });
+
+  describe("scanSessionMessages", () => {
+    it("returns empty state when client is undefined", async () => {
+      const state = await scanSessionMessages(undefined, "test-session");
+      expect(state.epicId).toBeUndefined();
+      expect(state.agentName).toBeUndefined();
+      expect(state.subtasks.size).toBe(0);
+    });
+
+    it("returns empty state when client is null", async () => {
+      const state = await scanSessionMessages(null, "test-session");
+      expect(state.epicId).toBeUndefined();
+      expect(state.subtasks.size).toBe(0);
+    });
+
+    it("extracts epic data from hive_create_epic tool call", async () => {
+      const mockClient = {
+        session: {
+          messages: async () => ({
+            data: [
+              {
+                info: { id: "msg-1", sessionID: "test-session" },
+                parts: [
+                  {
+                    type: "tool",
+                    tool: "hive_create_epic",
+                    state: {
+                      status: "completed",
+                      input: { epic_title: "Test Epic" },
+                      output: JSON.stringify({ epic: { id: "epic-123" } }),
+                      time: { start: 1000, end: 2000 },
+                    },
+                  },
+                ],
+              },
+            ],
+          }),
+        },
+      };
+
+      const state = await scanSessionMessages(mockClient, "test-session");
+      expect(state.epicId).toBe("epic-123");
+      expect(state.epicTitle).toBe("Test Epic");
+    });
+
+    it("extracts agent name from swarmmail_init tool call", async () => {
+      const mockClient = {
+        session: {
+          messages: async () => ({
+            data: [
+              {
+                info: { id: "msg-1", sessionID: "test-session" },
+                parts: [
+                  {
+                    type: "tool",
+                    tool: "swarmmail_init",
+                    state: {
+                      status: "completed",
+                      input: {},
+                      output: JSON.stringify({
+                        agent_name: "BlueLake",
+                        project_key: "/test/project",
+                      }),
+                      time: { start: 1000, end: 2000 },
+                    },
+                  },
+                ],
+              },
+            ],
+          }),
+        },
+      };
+
+      const state = await scanSessionMessages(mockClient, "test-session");
+      expect(state.agentName).toBe("BlueLake");
+      expect(state.projectPath).toBe("/test/project");
+    });
+
+    it("tracks subtasks from swarm_spawn_subtask tool calls", async () => {
+      const mockClient = {
+        session: {
+          messages: async () => ({
+            data: [
+              {
+                info: { id: "msg-1", sessionID: "test-session" },
+                parts: [
+                  {
+                    type: "tool",
+                    tool: "swarm_spawn_subtask",
+                    state: {
+                      status: "completed",
+                      input: {
+                        bead_id: "bd-123.1",
+                        epic_id: "epic-123",
+                        subtask_title: "Add auth",
+                        files: ["src/auth.ts"],
+                      },
+                      output: JSON.stringify({ worker: "RedMountain" }),
+                      time: { start: 1000, end: 2000 },
+                    },
+                  },
+                ],
+              },
+            ],
+          }),
+        },
+      };
+
+      const state = await scanSessionMessages(mockClient, "test-session");
+      expect(state.subtasks.size).toBe(1);
+      const subtask = state.subtasks.get("bd-123.1");
+      expect(subtask?.title).toBe("Add auth");
+      expect(subtask?.status).toBe("spawned");
+      expect(subtask?.worker).toBe("RedMountain");
+      expect(subtask?.files).toEqual(["src/auth.ts"]);
+    });
+
+    it("marks subtasks as completed from swarm_complete tool calls", async () => {
+      const mockClient = {
+        session: {
+          messages: async () => ({
+            data: [
+              {
+                info: { id: "msg-1", sessionID: "test-session" },
+                parts: [
+                  {
+                    type: "tool",
+                    tool: "swarm_spawn_subtask",
+                    state: {
+                      status: "completed",
+                      input: {
+                        bead_id: "bd-123.1",
+                        subtask_title: "Add auth",
+                      },
+                      output: "{}",
+                      time: { start: 1000, end: 2000 },
+                    },
+                  },
+                  {
+                    type: "tool",
+                    tool: "swarm_complete",
+                    state: {
+                      status: "completed",
+                      input: { bead_id: "bd-123.1" },
+                      output: "{}",
+                      time: { start: 3000, end: 4000 },
+                    },
+                  },
+                ],
+              },
+            ],
+          }),
+        },
+      };
+
+      const state = await scanSessionMessages(mockClient, "test-session");
+      const subtask = state.subtasks.get("bd-123.1");
+      expect(subtask?.status).toBe("completed");
+    });
+
+    it("tracks last action", async () => {
+      const mockClient = {
+        session: {
+          messages: async () => ({
+            data: [
+              {
+                info: { id: "msg-1", sessionID: "test-session" },
+                parts: [
+                  {
+                    type: "tool",
+                    tool: "swarm_status",
+                    state: {
+                      status: "completed",
+                      input: { epic_id: "epic-123", project_key: "/test" },
+                      output: "{}",
+                      time: { start: 5000, end: 6000 },
+                    },
+                  },
+                ],
+              },
+            ],
+          }),
+        },
+      };
+
+      const state = await scanSessionMessages(mockClient, "test-session");
+      expect(state.lastAction?.tool).toBe("swarm_status");
+      expect(state.lastAction?.timestamp).toBe(6000);
+    });
+
+    it("handles SDK errors gracefully", async () => {
+      const mockClient = {
+        session: {
+          messages: async () => {
+            throw new Error("SDK error");
+          },
+        },
+      };
+
+      // Should not throw, just return empty state
+      const state = await scanSessionMessages(mockClient, "test-session");
+      expect(state.subtasks.size).toBe(0);
+    });
+
+    it("respects limit parameter", async () => {
+      const mockClient = {
+        session: {
+          messages: async (opts: { query?: { limit?: number } }) => {
+            expect(opts.query?.limit).toBe(50);
+            return { data: [] };
+          },
+        },
+      };
+
+      await scanSessionMessages(mockClient, "test-session", 50);
     });
   });
 });