opencode-swarm-plugin 0.36.1 → 0.38.0

package/src/swarm-decompose.test.ts

@@ -0,0 +1,188 @@
+/**
+ * Swarm Decompose Unit Tests
+ *
+ * Tests for task decomposition, validation, and eval capture integration.
+ *
+ * TDD: Testing eval capture integration - verifies captureDecomposition() is called
+ * after successful validation with correct parameters.
+ */
+import { afterEach, beforeEach, describe, expect, test, spyOn } from "bun:test";
+import * as fs from "node:fs";
+import { swarm_validate_decomposition } from "./swarm-decompose";
+import * as evalCapture from "./eval-capture.js";
+
+// ============================================================================
+// Test Setup
+// ============================================================================
+
+const mockContext = {
+  sessionID: `test-decompose-${Date.now()}`,
+  messageID: `test-message-${Date.now()}`,
+  agent: "test-agent",
+  abort: new AbortController().signal,
+};
+
+let testProjectPath: string;
+
+beforeEach(() => {
+  testProjectPath = `/tmp/test-swarm-decompose-${Date.now()}`;
+  fs.mkdirSync(testProjectPath, { recursive: true });
+});
+
+afterEach(() => {
+  if (fs.existsSync(testProjectPath)) {
+    fs.rmSync(testProjectPath, { recursive: true, force: true });
+  }
+});
+
+// ============================================================================
+// Eval Capture Integration Tests
+// ============================================================================
+
+describe("captureDecomposition integration", () => {
+  test("calls captureDecomposition after successful validation with all params", async () => {
+    // Spy on captureDecomposition
+    const captureDecompositionSpy = spyOn(evalCapture, "captureDecomposition");
+
+    const validCellTree = JSON.stringify({
+      epic: {
+        title: "Add OAuth",
+        description: "Implement OAuth authentication",
+      },
+      subtasks: [
+        {
+          title: "Add OAuth provider config",
+          description: "Set up Google OAuth",
+          files: ["src/auth/google.ts", "src/auth/config.ts"],
+          dependencies: [],
+          estimated_complexity: 2,
+        },
+        {
+          title: "Add login UI",
+          description: "Create login button component",
+          files: ["src/components/LoginButton.tsx"],
+          dependencies: [0],
+          estimated_complexity: 1,
+        },
+      ],
+    });
+
+    const result = await swarm_validate_decomposition.execute(
+      {
+        response: validCellTree,
+        project_path: testProjectPath,
+        task: "Add user authentication",
+        context: "Using NextAuth.js",
+        strategy: "feature-based" as const,
+        epic_id: "test-epic-123",
+      },
+      mockContext,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.valid).toBe(true);
+
+    // Verify captureDecomposition was called with correct params
+    expect(captureDecompositionSpy).toHaveBeenCalledTimes(1);
+    expect(captureDecompositionSpy).toHaveBeenCalledWith({
+      epicId: "test-epic-123",
+      projectPath: testProjectPath,
+      task: "Add user authentication",
+      context: "Using NextAuth.js",
+      strategy: "feature-based",
+      epicTitle: "Add OAuth",
+      epicDescription: "Implement OAuth authentication",
+      subtasks: [
+        {
+          title: "Add OAuth provider config",
+          description: "Set up Google OAuth",
+          files: ["src/auth/google.ts", "src/auth/config.ts"],
+          dependencies: [],
+          estimated_complexity: 2,
+        },
+        {
+          title: "Add login UI",
+          description: "Create login button component",
+          files: ["src/components/LoginButton.tsx"],
+          dependencies: [0],
+          estimated_complexity: 1,
+        },
+      ],
+    });
+
+    captureDecompositionSpy.mockRestore();
+  });
+
+  test("does not call captureDecomposition when validation fails", async () => {
+    const captureDecompositionSpy = spyOn(evalCapture, "captureDecomposition");
+
+    // Invalid CellTree - missing required fields
+    const invalidCellTree = JSON.stringify({
+      epic: { title: "Missing subtasks" },
+      // No subtasks array
+    });
+
+    const result = await swarm_validate_decomposition.execute(
+      {
+        response: invalidCellTree,
+        project_path: testProjectPath,
+        task: "Add auth",
+        strategy: "auto" as const,
+        epic_id: "test-epic-456",
+      },
+      mockContext,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.valid).toBe(false);
+
+    // Verify captureDecomposition was NOT called
+    expect(captureDecompositionSpy).not.toHaveBeenCalled();
+
+    captureDecompositionSpy.mockRestore();
+  });
+
+  test("handles optional context and description fields", async () => {
+    const captureDecompositionSpy = spyOn(evalCapture, "captureDecomposition");
+
+    const validCellTree = JSON.stringify({
+      epic: {
+        title: "Fix bug",
+        // No description
+      },
+      subtasks: [
+        {
+          title: "Add test",
+          files: ["src/test.ts"],
+          dependencies: [],
+          estimated_complexity: 1,
+        },
+      ],
+    });
+
+    const result = await swarm_validate_decomposition.execute(
+      {
+        response: validCellTree,
+        project_path: testProjectPath,
+        task: "Fix the auth bug",
+        // No context
+        strategy: "risk-based" as const,
+        epic_id: "test-epic-789",
+      },
+      mockContext,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.valid).toBe(true);
+
+    // Verify captureDecomposition was called without optional fields
+    expect(captureDecompositionSpy).toHaveBeenCalledTimes(1);
+    const call = captureDecompositionSpy.mock.calls[0];
+    expect(call[0].epicId).toBe("test-epic-789");
+    expect(call[0].context).toBeUndefined();
+    // Schema default makes description empty string instead of undefined
+    expect(call[0].epicDescription).toBe("");
+
+    captureDecompositionSpy.mockRestore();
+  });
+});

package/src/swarm-decompose.ts

@@ -535,11 +535,31 @@ export const swarm_decompose = tool({
  * Use this after the agent responds to swarm:decompose to validate the structure.
  */
 export const swarm_validate_decomposition = tool({
-  description: "Validate a decomposition response against CellTreeSchema",
+  description: "Validate a decomposition response against CellTreeSchema and capture for eval",
   args: {
     response: tool.schema
       .string()
       .describe("JSON response from agent (CellTree format)"),
+    project_path: tool.schema
+      .string()
+      .optional()
+      .describe("Project path for eval capture"),
+    task: tool.schema
+      .string()
+      .optional()
+      .describe("Original task description for eval capture"),
+    context: tool.schema
+      .string()
+      .optional()
+      .describe("Context provided for decomposition"),
+    strategy: tool.schema
+      .enum(["file-based", "feature-based", "risk-based", "auto"])
+      .optional()
+      .describe("Decomposition strategy used"),
+    epic_id: tool.schema
+      .string()
+      .optional()
+      .describe("Epic ID for eval capture"),
   },
   async execute(args) {
     try {
@@ -597,6 +617,37 @@ export const swarm_validate_decomposition = tool({
         validated.subtasks,
       );
 
+      // Capture decomposition for eval if all required params provided
+      if (
+        args.project_path &&
+        args.task &&
+        args.strategy &&
+        args.epic_id
+      ) {
+        try {
+          const { captureDecomposition } = await import("./eval-capture.js");
+          captureDecomposition({
+            epicId: args.epic_id,
+            projectPath: args.project_path,
+            task: args.task,
+            context: args.context,
+            strategy: args.strategy,
+            epicTitle: validated.epic.title,
+            epicDescription: validated.epic.description,
+            subtasks: validated.subtasks.map((s) => ({
+              title: s.title,
+              description: s.description,
+              files: s.files,
+              dependencies: s.dependencies,
+              estimated_complexity: s.estimated_complexity,
+            })),
+          });
+        } catch (error) {
+          // Non-fatal - don't block validation if capture fails
+          console.warn("[swarm_validate_decomposition] Failed to capture decomposition:", error);
+        }
+      }
+
       return JSON.stringify(
         {
           valid: true,

package/src/swarm-orchestrate.test.ts

@@ -6,10 +6,13 @@
  * - Researcher spawning for identified technologies
  * - Summary collection from semantic-memory
  * - Research result aggregation
+ * - Eval capture integration (captureSubtaskOutcome wiring)
  */
 
-import { describe, test, expect, beforeEach } from "bun:test";
-import { runResearchPhase, extractTechStack } from "./swarm-orchestrate";
+import { describe, test, expect, beforeEach, afterEach, spyOn } from "bun:test";
+import { runResearchPhase, extractTechStack, swarm_complete } from "./swarm-orchestrate";
+import * as evalCapture from "./eval-capture.js";
+import * as fs from "node:fs";
 
 describe("extractTechStack", () => {
   test("extracts Next.js from task description", () => {
@@ -115,9 +118,269 @@ describe("runResearchPhase", () => {
   });
 });
 
-describe("swarm_research_phase tool", () => {
-  test.todo("exposes research phase as plugin tool");
-  test.todo("validates task parameter");
-  test.todo("validates project_path parameter");
-  test.todo("returns JSON string with research results");
+// describe("swarm_research_phase tool", () => {
+//   test.todo("exposes research phase as plugin tool");
+//   test.todo("validates task parameter");
+//   test.todo("validates project_path parameter");
+//   test.todo("returns JSON string with research results");
+// });
+
+// ============================================================================
+// Eval Capture Integration Tests (swarm_complete)
+// ============================================================================
+
+describe("captureSubtaskOutcome integration", () => {
+  const mockContext = {
+    sessionID: `test-complete-${Date.now()}`,
+    messageID: `test-message-${Date.now()}`,
+    agent: "test-agent",
+    abort: new AbortController().signal,
+  };
+
+  let testProjectPath: string;
+
+  beforeEach(async () => {
+    testProjectPath = `/tmp/test-swarm-complete-${Date.now()}`;
+    fs.mkdirSync(testProjectPath, { recursive: true });
+    
+    // Create .hive directory and issues.jsonl
+    const hiveDir = `${testProjectPath}/.hive`;
+    fs.mkdirSync(hiveDir, { recursive: true });
+    fs.writeFileSync(`${hiveDir}/issues.jsonl`, "", "utf-8");
+    
+    // Set hive working directory to testProjectPath
+    const { setHiveWorkingDirectory } = await import("./hive");
+    setHiveWorkingDirectory(testProjectPath);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testProjectPath)) {
+      fs.rmSync(testProjectPath, { recursive: true, force: true });
+    }
+  });
+
+  test("calls captureSubtaskOutcome after successful completion with all params", async () => {
+    // Import hive tools
+    const { hive_create_epic } = await import("./hive");
+    
+    // Spy on captureSubtaskOutcome
+    const captureOutcomeSpy = spyOn(evalCapture, "captureSubtaskOutcome");
+
+    // Create an epic with a subtask using hive_create_epic
+    const epicResult = await hive_create_epic.execute({
+      epic_title: "Add OAuth",
+      epic_description: "Implement OAuth authentication",
+      subtasks: [
+        {
+          title: "Add auth service",
+          priority: 2,
+          files: ["src/auth/service.ts", "src/auth/schema.ts"],
+        },
+      ],
+    }, mockContext);
+    
+    const epicData = JSON.parse(epicResult);
+    expect(epicData.success).toBe(true);
+    
+    const epicId = epicData.epic.id;
+    const beadId = epicData.subtasks[0].id;
+
+    const startTime = Date.now() - 120000; // Started 2 minutes ago
+    const plannedFiles = ["src/auth/service.ts", "src/auth/schema.ts"];
+    const actualFiles = ["src/auth/service.ts", "src/auth/schema.ts", "src/auth/types.ts"];
+
+    // Call swarm_complete
+    const result = await swarm_complete.execute(
+      {
+        project_key: testProjectPath,
+        agent_name: "TestAgent",
+        bead_id: beadId,
+        summary: "Implemented OAuth service with JWT strategy",
+        files_touched: actualFiles,
+        skip_verification: true, // Skip verification for test
+        skip_review: true, // Skip review for test
+        planned_files: plannedFiles,
+        start_time: startTime,
+        error_count: 0,
+        retry_count: 0,
+      },
+      mockContext,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.success).toBe(true);
+
+    // Verify captureSubtaskOutcome was called with correct params
+    expect(captureOutcomeSpy).toHaveBeenCalledTimes(1);
+    
+    const call = captureOutcomeSpy.mock.calls[0][0];
+    expect(call.epicId).toBe(epicId);
+    expect(call.projectPath).toBe(testProjectPath);
+    expect(call.beadId).toBe(beadId);
+    expect(call.title).toBe("Add auth service");
+    expect(call.plannedFiles).toEqual(plannedFiles);
+    expect(call.actualFiles).toEqual(actualFiles);
+    expect(call.durationMs).toBeGreaterThan(0);
+    expect(call.errorCount).toBe(0);
+    expect(call.retryCount).toBe(0);
+    expect(call.success).toBe(true);
+
+    captureOutcomeSpy.mockRestore();
+  });
+
+  test("does not call captureSubtaskOutcome when required params missing", async () => {
+    const { hive_create_epic } = await import("./hive");
+    const captureOutcomeSpy = spyOn(evalCapture, "captureSubtaskOutcome");
+
+    // Create an epic with a subtask
+    const epicResult = await hive_create_epic.execute({
+      epic_title: "Fix bug",
+      subtasks: [
+        {
+          title: "Fix auth bug",
+          priority: 1,
+          files: ["src/auth.ts"],
+        },
+      ],
+    }, mockContext);
+    
+    const epicData = JSON.parse(epicResult);
+    const beadId = epicData.subtasks[0].id;
+
+    // Call without planned_files or start_time
+    const result = await swarm_complete.execute(
+      {
+        project_key: testProjectPath,
+        agent_name: "TestAgent",
+        bead_id: beadId,
+        summary: "Fixed the bug",
+        skip_verification: true,
+        skip_review: true,
+        // No planned_files, start_time
+      },
+      mockContext,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.success).toBe(true);
+
+    // Capture should still be called, but with default values
+    // (The function is called in all success cases, it just handles missing params)
+    expect(captureOutcomeSpy).toHaveBeenCalledTimes(1);
+
+    captureOutcomeSpy.mockRestore();
+  });
+});
+
+// ============================================================================
+// Eval Capture Integration Tests (swarm_record_outcome)
+// ============================================================================
+
+describe("finalizeEvalRecord integration", () => {
+  const mockContext = {
+    sessionID: `test-finalize-${Date.now()}`,
+    messageID: `test-message-${Date.now()}`,
+    agent: "test-agent",
+    abort: new AbortController().signal,
+  };
+
+  test("calls finalizeEvalRecord when project_path and epic_id provided", async () => {
+    const { swarm_record_outcome } = await import("./swarm-orchestrate");
+    
+    // Spy on finalizeEvalRecord
+    const finalizeEvalSpy = spyOn(evalCapture, "finalizeEvalRecord");
+    finalizeEvalSpy.mockReturnValue(null); // Mock return value
+
+    const testProjectPath = "/tmp/test-project";
+    const testEpicId = "bd-test123";
+    const testBeadId = `${testEpicId}.0`;
+
+    // Call swarm_record_outcome with epic_id and project_path
+    await swarm_record_outcome.execute({
+      bead_id: testBeadId,
+      duration_ms: 120000,
+      error_count: 0,
+      retry_count: 0,
+      success: true,
+      files_touched: ["src/test.ts"],
+      epic_id: testEpicId,
+      project_path: testProjectPath,
+    }, mockContext);
+
+    // Verify finalizeEvalRecord was called
+    expect(finalizeEvalSpy).toHaveBeenCalledTimes(1);
+    expect(finalizeEvalSpy).toHaveBeenCalledWith({
+      epicId: testEpicId,
+      projectPath: testProjectPath,
+    });
+
+    finalizeEvalSpy.mockRestore();
+  });
+
+  test("does not call finalizeEvalRecord when epic_id or project_path missing", async () => {
+    const { swarm_record_outcome } = await import("./swarm-orchestrate");
+    
+    // Spy on finalizeEvalRecord
+    const finalizeEvalSpy = spyOn(evalCapture, "finalizeEvalRecord");
+
+    const testBeadId = "bd-test123.0";
+
+    // Call without epic_id or project_path
+    await swarm_record_outcome.execute({
+      bead_id: testBeadId,
+      duration_ms: 120000,
+      error_count: 0,
+      retry_count: 0,
+      success: true,
+    }, mockContext);
+
+    // Verify finalizeEvalRecord was NOT called
+    expect(finalizeEvalSpy).toHaveBeenCalledTimes(0);
+
+    finalizeEvalSpy.mockRestore();
+  });
+
+  test("includes finalized record in response when available", async () => {
+    const { swarm_record_outcome } = await import("./swarm-orchestrate");
+    
+    // Mock finalizeEvalRecord to return a record
+    const mockFinalRecord = {
+      id: "bd-test123",
+      timestamp: new Date().toISOString(),
+      project_path: "/tmp/test-project",
+      task: "Test task",
+      strategy: "file-based" as const,
+      subtask_count: 2,
+      epic_title: "Test Epic",
+      subtasks: [],
+      overall_success: true,
+      total_duration_ms: 240000,
+      total_errors: 0,
+    };
+
+    const finalizeEvalSpy = spyOn(evalCapture, "finalizeEvalRecord");
+    finalizeEvalSpy.mockReturnValue(mockFinalRecord);
+
+    const testProjectPath = "/tmp/test-project";
+    const testEpicId = "bd-test123";
+    const testBeadId = `${testEpicId}.0`;
+
+    // Call with epic_id and project_path
+    const result = await swarm_record_outcome.execute({
+      bead_id: testBeadId,
+      duration_ms: 120000,
+      error_count: 0,
+      retry_count: 0,
+      success: true,
+      epic_id: testEpicId,
+      project_path: testProjectPath,
+    }, mockContext);
+
+    // Parse result and check for finalized record
+    const parsed = JSON.parse(result);
+    expect(parsed).toHaveProperty("finalized_eval_record");
+    expect(parsed.finalized_eval_record).toEqual(mockFinalRecord);
+
+    finalizeEvalSpy.mockRestore();
+  });
 });