opencode-swarm-plugin 0.39.1 → 0.40.0

package/src/eval-capture.test.ts

@@ -13,7 +13,7 @@ import {
   captureCoordinatorEvent,
   captureCompactionEvent,
   saveSession,
-} from "./eval-capture.js";
+} from "./eval-capture.ts";
 
 describe("CoordinatorEvent schemas", () => {
   describe("DECISION events", () => {
@@ -82,6 +82,110 @@ describe("CoordinatorEvent schemas", () => {
 
       expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
     });
+
+    test("validates researcher_spawned event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "researcher_spawned",
+        payload: {
+          researcher_id: "BlueLake",
+          research_topic: "Next.js Cache Components",
+          tools_used: ["pdf-brain", "context7"],
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates skill_loaded event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "skill_loaded",
+        payload: {
+          skill_name: "testing-patterns",
+          context: "Adding tests to legacy code",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates inbox_checked event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "inbox_checked",
+        payload: {
+          message_count: 3,
+          urgent_count: 1,
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates blocker_resolved event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "blocker_resolved",
+        payload: {
+          worker_id: "GreenStorm",
+          subtask_id: "bd-123.2",
+          blocker_type: "dependency",
+          resolution: "Unblocked via coordinator action",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates scope_change_approved event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "scope_change_approved",
+        payload: {
+          worker_id: "BlueLake",
+          subtask_id: "bd-123.1",
+          original_scope: "Add auth service",
+          new_scope: "Add auth service + email validation",
+          estimated_time_add: 900000, // 15 min in ms
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates scope_change_rejected event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "scope_change_rejected",
+        payload: {
+          worker_id: "BlueLake",
+          subtask_id: "bd-123.1",
+          requested_scope: "Add auth service + OAuth + SSO",
+          rejection_reason: "Too large for single subtask",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
   });
 
   describe("VIOLATION events", () => {
@@ -215,6 +319,25 @@ describe("CoordinatorEvent schemas", () => {
 
       expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
     });
+
+    test("validates blocker_detected event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "OUTCOME",
+        outcome_type: "blocker_detected",
+        payload: {
+          worker_id: "GreenStorm",
+          subtask_id: "bd-123.2",
+          blocker_type: "dependency",
+          blocker_description: "Waiting for database schema from bd-123.1",
+          reported_at: new Date().toISOString(),
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
   });
 });
 
@@ -810,3 +933,83 @@ describe("captureCompactionEvent", () => {
     expect(capturedEvents[4].compaction_type).toBe("tool_call_tracked");
   });
 });
+
+describe("hive_create_epic integration - decomposition_complete event", () => {
+  let sessionDir: string;
+  let sessionId: string;
+  const testProjectPath = "/tmp/test-epic-decomposition";
+
+  beforeEach(() => {
+    sessionDir = path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+    sessionId = `test-epic-${Date.now()}`;
+  });
+
+  afterEach(() => {
+    // Clean up test session file
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    if (fs.existsSync(sessionPath)) {
+      fs.unlinkSync(sessionPath);
+    }
+  });
+
+  test("captures decomposition_complete event after hive_create_epic succeeds", async () => {
+    // Test the event capture by calling captureCoordinatorEvent directly
+    // Testing hive_create_epic directly would require full plugin infrastructure
+    
+    // GIVEN: We simulate what hive_create_epic does after epic creation
+    const epicId = `test-epic-${Date.now()}`;
+    const subtasks = [
+      { title: "Subtask 1", files: ["src/a.ts"] },
+      { title: "Subtask 2", files: ["src/b.ts", "src/c.ts"] },
+      { title: "Subtask 3", files: ["src/d.ts"] },
+    ];
+    
+    // Build files_per_subtask map (same logic as hive.ts)
+    const filesPerSubtask: Record<number, string[]> = {};
+    subtasks.forEach((subtask, index) => {
+      if (subtask.files && subtask.files.length > 0) {
+        filesPerSubtask[index] = subtask.files;
+      }
+    });
+
+    // WHEN: decomposition_complete event is captured
+    captureCoordinatorEvent({
+      session_id: sessionId,
+      epic_id: epicId,
+      timestamp: new Date().toISOString(),
+      event_type: "DECISION",
+      decision_type: "decomposition_complete",
+      payload: {
+        subtask_count: subtasks.length,
+        strategy_used: "file-based",
+        files_per_subtask: filesPerSubtask,
+        epic_title: "Test Epic for Event Capture",
+        task: "Original task description",
+      },
+    });
+
+    // THEN: Event should be written to session file
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    expect(fs.existsSync(sessionPath)).toBe(true);
+
+    const content = fs.readFileSync(sessionPath, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    expect(lines.length).toBe(1);
+
+    // Verify event structure
+    const event = JSON.parse(lines[0]);
+    expect(event.session_id).toBe(sessionId);
+    expect(event.epic_id).toBe(epicId);
+    expect(event.event_type).toBe("DECISION");
+    expect(event.decision_type).toBe("decomposition_complete");
+    expect(event.payload.subtask_count).toBe(3);
+    expect(event.payload.strategy_used).toBe("file-based");
+    expect(event.payload.files_per_subtask).toEqual({
+      0: ["src/a.ts"],
+      1: ["src/b.ts", "src/c.ts"],
+      2: ["src/d.ts"],
+    });
+    expect(event.payload.epic_title).toBe("Test Epic for Event Capture");
+    expect(event.payload.task).toBe("Original task description");
+  });
+});

package/src/eval-capture.ts

@@ -13,9 +13,9 @@
  * 6. Session capture: full coordinator session to ~/.config/swarm-tools/sessions/
  *
  * Event types:
- * - DECISION: strategy_selected, worker_spawned, review_completed, decomposition_complete
+ * - DECISION: strategy_selected, worker_spawned, review_completed, decomposition_complete, researcher_spawned, skill_loaded, inbox_checked, blocker_resolved, scope_change_approved, scope_change_rejected
  * - VIOLATION: coordinator_edited_file, coordinator_ran_tests, coordinator_reserved_files, no_worker_spawned
- * - OUTCOME: subtask_success, subtask_retry, subtask_failed, epic_complete
+ * - OUTCOME: subtask_success, subtask_retry, subtask_failed, epic_complete, blocker_detected
  * - COMPACTION: detection_complete, prompt_generated, context_injected, resumption_started, tool_call_tracked
  *
  * @module eval-capture
@@ -143,6 +143,12 @@ export const CoordinatorEventSchema = z.discriminatedUnion("event_type", [
       "worker_spawned",
       "review_completed",
       "decomposition_complete",
+      "researcher_spawned",
+      "skill_loaded",
+      "inbox_checked",
+      "blocker_resolved",
+      "scope_change_approved",
+      "scope_change_rejected",
     ]),
     payload: z.any(),
   }),
@@ -171,6 +177,7 @@ export const CoordinatorEventSchema = z.discriminatedUnion("event_type", [
       "subtask_retry",
       "subtask_failed",
       "epic_complete",
+      "blocker_detected",
     ]),
     payload: z.any(),
   }),
@@ -687,6 +694,191 @@ export function captureCompactionEvent(params: {
   captureCoordinatorEvent(event);
 }
 
+/**
+ * Capture a researcher spawned event
+ *
+ * Called when coordinator spawns a swarm-researcher to handle unfamiliar technology
+ * or gather documentation before decomposition.
+ */
+export function captureResearcherSpawned(params: {
+  session_id: string;
+  epic_id: string;
+  researcher_id: string;
+  research_topic: string;
+  tools_used?: string[];
+}): void {
+  const event: CoordinatorEvent = {
+    session_id: params.session_id,
+    epic_id: params.epic_id,
+    timestamp: new Date().toISOString(),
+    event_type: "DECISION",
+    decision_type: "researcher_spawned",
+    payload: {
+      researcher_id: params.researcher_id,
+      research_topic: params.research_topic,
+      tools_used: params.tools_used || [],
+    },
+  };
+
+  captureCoordinatorEvent(event);
+}
+
+/**
+ * Capture a skill loaded event
+ *
+ * Called when coordinator loads domain knowledge via skills_use().
+ */
+export function captureSkillLoaded(params: {
+  session_id: string;
+  epic_id: string;
+  skill_name: string;
+  context?: string;
+}): void {
+  const event: CoordinatorEvent = {
+    session_id: params.session_id,
+    epic_id: params.epic_id,
+    timestamp: new Date().toISOString(),
+    event_type: "DECISION",
+    decision_type: "skill_loaded",
+    payload: {
+      skill_name: params.skill_name,
+      context: params.context,
+    },
+  };
+
+  captureCoordinatorEvent(event);
+}
+
+/**
+ * Capture an inbox checked event
+ *
+ * Called when coordinator checks swarmmail inbox for worker messages.
+ * Tracks monitoring frequency and responsiveness.
+ */
+export function captureInboxChecked(params: {
+  session_id: string;
+  epic_id: string;
+  message_count: number;
+  urgent_count: number;
+}): void {
+  const event: CoordinatorEvent = {
+    session_id: params.session_id,
+    epic_id: params.epic_id,
+    timestamp: new Date().toISOString(),
+    event_type: "DECISION",
+    decision_type: "inbox_checked",
+    payload: {
+      message_count: params.message_count,
+      urgent_count: params.urgent_count,
+    },
+  };
+
+  captureCoordinatorEvent(event);
+}
+
+/**
+ * Capture a blocker resolved event
+ *
+ * Called when coordinator successfully unblocks a worker.
+ */
+export function captureBlockerResolved(params: {
+  session_id: string;
+  epic_id: string;
+  worker_id: string;
+  subtask_id: string;
+  blocker_type: string;
+  resolution: string;
+}): void {
+  const event: CoordinatorEvent = {
+    session_id: params.session_id,
+    epic_id: params.epic_id,
+    timestamp: new Date().toISOString(),
+    event_type: "DECISION",
+    decision_type: "blocker_resolved",
+    payload: {
+      worker_id: params.worker_id,
+      subtask_id: params.subtask_id,
+      blocker_type: params.blocker_type,
+      resolution: params.resolution,
+    },
+  };
+
+  captureCoordinatorEvent(event);
+}
+
+/**
+ * Capture a scope change decision event
+ *
+ * Called when coordinator approves or rejects a worker's scope expansion request.
+ */
+export function captureScopeChangeDecision(params: {
+  session_id: string;
+  epic_id: string;
+  worker_id: string;
+  subtask_id: string;
+  approved: boolean;
+  original_scope?: string;
+  new_scope?: string;
+  requested_scope?: string;
+  rejection_reason?: string;
+  estimated_time_add?: number;
+}): void {
+  const event: CoordinatorEvent = {
+    session_id: params.session_id,
+    epic_id: params.epic_id,
+    timestamp: new Date().toISOString(),
+    event_type: "DECISION",
+    decision_type: params.approved ? "scope_change_approved" : "scope_change_rejected",
+    payload: params.approved
+      ? {
+          worker_id: params.worker_id,
+          subtask_id: params.subtask_id,
+          original_scope: params.original_scope,
+          new_scope: params.new_scope,
+          estimated_time_add: params.estimated_time_add,
+        }
+      : {
+          worker_id: params.worker_id,
+          subtask_id: params.subtask_id,
+          requested_scope: params.requested_scope,
+          rejection_reason: params.rejection_reason,
+        },
+  };
+
+  captureCoordinatorEvent(event);
+}
+
+/**
+ * Capture a blocker detected event
+ *
+ * Called when a worker reports being blocked (OUTCOME event, not DECISION).
+ */
+export function captureBlockerDetected(params: {
+  session_id: string;
+  epic_id: string;
+  worker_id: string;
+  subtask_id: string;
+  blocker_type: string;
+  blocker_description: string;
+}): void {
+  const event: CoordinatorEvent = {
+    session_id: params.session_id,
+    epic_id: params.epic_id,
+    timestamp: new Date().toISOString(),
+    event_type: "OUTCOME",
+    outcome_type: "blocker_detected",
+    payload: {
+      worker_id: params.worker_id,
+      subtask_id: params.subtask_id,
+      blocker_type: params.blocker_type,
+      blocker_description: params.blocker_description,
+      reported_at: new Date().toISOString(),
+    },
+  };
+
+  captureCoordinatorEvent(event);
+}
+
 /**
  * Read all events from a session file
  */

package/src/eval-runner.test.ts

@@ -0,0 +1,96 @@
+/**
+ * Tests for eval-runner - Programmatic evalite execution
+ *
+ * TDD: These tests MUST fail initially, then pass after implementation.
+ */
+
+import { describe, test, expect, beforeAll } from "bun:test";
+import { runEvals } from "./eval-runner";
+import path from "node:path";
+
+// Use project root for all tests
+const PROJECT_ROOT = path.resolve(import.meta.dir, "..");
+
+describe("runEvals", () => {
+  test("runs all evals when no suite filter provided", async () => {
+    const result = await runEvals({
+      cwd: PROJECT_ROOT,
+    });
+
+    // Even if some evals fail, we should get results
+    expect(typeof result.success).toBe("boolean");
+    expect(typeof result.totalSuites).toBe("number");
+    expect(typeof result.totalEvals).toBe("number");
+    expect(typeof result.averageScore).toBe("number");
+    expect(Array.isArray(result.suites)).toBe(true);
+
+    // Should have at least the example.eval.ts suite
+    expect(result.totalSuites).toBeGreaterThan(0);
+    expect(result.suites.length).toBeGreaterThan(0);
+  }, 60000); // 60s timeout for full eval run
+
+  test("filters evals by suite name", async () => {
+    const result = await runEvals({
+      cwd: PROJECT_ROOT,
+      suiteFilter: "example",
+    });
+
+    expect(result.success).toBe(true);
+    // All suite filepaths should contain "example"
+    for (const suite of result.suites) {
+      expect(suite.filepath.toLowerCase()).toContain("example");
+    }
+  }, 30000);
+
+  test("respects score threshold", async () => {
+    const result = await runEvals({
+      cwd: PROJECT_ROOT,
+      suiteFilter: "example", // Known good eval
+      scoreThreshold: 0, // Very low threshold, should pass
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.averageScore).toBeGreaterThanOrEqual(0);
+  }, 30000);
+
+  test("returns structured suite results with scores", async () => {
+    const result = await runEvals({
+      cwd: PROJECT_ROOT,
+      suiteFilter: "example",
+    });
+
+    expect(result.suites.length).toBeGreaterThan(0);
+    
+    const suite = result.suites[0];
+    expect(suite).toMatchObject({
+      name: expect.any(String),
+      filepath: expect.any(String),
+      status: expect.stringMatching(/^(success|fail|running)$/),
+      duration: expect.any(Number),
+      averageScore: expect.any(Number),
+      evalCount: expect.any(Number),
+    });
+  }, 30000);
+
+  test("handles errors gracefully", async () => {
+    const result = await runEvals({
+      cwd: "/nonexistent/path",
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+    expect(result.suites).toEqual([]);
+  }, 10000);
+
+  test("returns empty results when no evals match filter", async () => {
+    const result = await runEvals({
+      cwd: PROJECT_ROOT,
+      suiteFilter: "nonexistent-eval-name-xyz",
+    });
+
+    // Should succeed but with no suites
+    expect(result.success).toBe(true);
+    expect(result.totalSuites).toBe(0);
+    expect(result.suites).toEqual([]);
+  }, 10000);
+});