opencode-swarm-plugin 0.35.0 → 0.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.35.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,279 +332,6 @@ describe("Compaction Hook", () => {
     });
   });
 
-  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();
@@ -736,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);
     });
   });
 });