opencode-swarm-plugin 0.4.0 → 0.6.0

package/src/swarm.integration.test.ts

@@ -16,6 +16,8 @@ import {
   swarm_complete,
   swarm_subtask_prompt,
   swarm_evaluation_prompt,
+  swarm_select_strategy,
+  swarm_plan_prompt,
   formatSubtaskPromptV2,
   SUBTASK_PROMPT_V2,
 } from "./swarm";
@@ -119,6 +121,288 @@ describe("swarm_decompose", () => {
   });
 });
 
+// ============================================================================
+// Strategy Selection Tests
+// ============================================================================
+
+describe("swarm_select_strategy", () => {
+  it("selects feature-based for 'add' tasks", async () => {
+    const result = await swarm_select_strategy.execute(
+      {
+        task: "Add user authentication with OAuth",
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed.strategy).toBe("feature-based");
+    expect(parsed.confidence).toBeGreaterThan(0.5);
+    expect(parsed.reasoning).toContain("add");
+    expect(parsed.guidelines).toBeInstanceOf(Array);
+    expect(parsed.anti_patterns).toBeInstanceOf(Array);
+  });
+
+  it("selects file-based for 'refactor' tasks", async () => {
+    const result = await swarm_select_strategy.execute(
+      {
+        task: "Refactor all components to use new API",
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed.strategy).toBe("file-based");
+    expect(parsed.confidence).toBeGreaterThanOrEqual(0.5);
+    expect(parsed.reasoning).toContain("refactor");
+  });
+
+  it("selects risk-based for 'fix security' tasks", async () => {
+    const result = await swarm_select_strategy.execute(
+      {
+        task: "Fix security vulnerability in authentication",
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed.strategy).toBe("risk-based");
+    expect(parsed.confidence).toBeGreaterThan(0.5);
+    // Should match either 'fix' or 'security'
+    expect(
+      parsed.reasoning.includes("fix") || parsed.reasoning.includes("security"),
+    ).toBe(true);
+  });
+
+  it("defaults to feature-based when no keywords match", async () => {
+    const result = await swarm_select_strategy.execute(
+      {
+        task: "Something completely unrelated without keywords",
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed.strategy).toBe("feature-based");
+    // Confidence should be lower without keyword matches
+    expect(parsed.confidence).toBeLessThanOrEqual(0.6);
+    expect(parsed.reasoning).toContain("Defaulting to feature-based");
+  });
+
+  it("includes confidence score and reasoning", async () => {
+    const result = await swarm_select_strategy.execute(
+      {
+        task: "Implement new dashboard feature",
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed).toHaveProperty("strategy");
+    expect(parsed).toHaveProperty("confidence");
+    expect(parsed).toHaveProperty("reasoning");
+    expect(parsed).toHaveProperty("description");
+    expect(typeof parsed.confidence).toBe("number");
+    expect(parsed.confidence).toBeGreaterThanOrEqual(0);
+    expect(parsed.confidence).toBeLessThanOrEqual(1);
+    expect(typeof parsed.reasoning).toBe("string");
+    expect(parsed.reasoning.length).toBeGreaterThan(0);
+  });
+
+  it("includes alternative strategies with scores", async () => {
+    const result = await swarm_select_strategy.execute(
+      {
+        task: "Build new payment processing module",
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed).toHaveProperty("alternatives");
+    expect(parsed.alternatives).toBeInstanceOf(Array);
+    expect(parsed.alternatives.length).toBe(2); // 3 strategies - 1 selected = 2 alternatives
+
+    for (const alt of parsed.alternatives) {
+      expect(alt).toHaveProperty("strategy");
+      expect(alt).toHaveProperty("description");
+      expect(alt).toHaveProperty("score");
+      expect(["file-based", "feature-based", "risk-based"]).toContain(
+        alt.strategy,
+      );
+      expect(typeof alt.score).toBe("number");
+    }
+  });
+
+  it("includes codebase context in reasoning when provided", async () => {
+    const result = await swarm_select_strategy.execute(
+      {
+        task: "Add new API endpoint",
+        codebase_context: "Using Express.js with TypeScript and PostgreSQL",
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed.reasoning).toContain("Express.js");
+  });
+});
+
+// ============================================================================
+// Planning Prompt Tests
+// ============================================================================
+
+describe("swarm_plan_prompt", () => {
+  it("auto-selects strategy when not specified", async () => {
+    const result = await swarm_plan_prompt.execute(
+      {
+        task: "Add user settings page",
+        max_subtasks: 3,
+        query_cass: false, // Disable CASS to isolate test
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed).toHaveProperty("prompt");
+    expect(parsed).toHaveProperty("strategy");
+    expect(parsed.strategy).toHaveProperty("selected");
+    expect(parsed.strategy).toHaveProperty("reasoning");
+    expect(parsed.strategy.selected).toBe("feature-based"); // 'add' keyword
+  });
+
+  it("uses explicit strategy when provided", async () => {
+    const result = await swarm_plan_prompt.execute(
+      {
+        task: "Do something",
+        strategy: "risk-based",
+        max_subtasks: 3,
+        query_cass: false,
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed.strategy.selected).toBe("risk-based");
+    expect(parsed.strategy.reasoning).toContain("User-specified strategy");
+  });
+
+  it("includes strategy guidelines in prompt", async () => {
+    const result = await swarm_plan_prompt.execute(
+      {
+        task: "Refactor the codebase",
+        max_subtasks: 4,
+        query_cass: false,
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    // Prompt should contain strategy-specific guidelines
+    expect(parsed.prompt).toContain("## Strategy:");
+    expect(parsed.prompt).toContain("### Guidelines");
+    expect(parsed.prompt).toContain("### Anti-Patterns");
+    expect(parsed.prompt).toContain("### Examples");
+  });
+
+  it("includes anti-patterns in output", async () => {
+    const result = await swarm_plan_prompt.execute(
+      {
+        task: "Build new feature",
+        max_subtasks: 3,
+        query_cass: false,
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed.strategy).toHaveProperty("anti_patterns");
+    expect(parsed.strategy.anti_patterns).toBeInstanceOf(Array);
+    expect(parsed.strategy.anti_patterns.length).toBeGreaterThan(0);
+  });
+
+  it("returns expected_schema and validation_note", async () => {
+    const result = await swarm_plan_prompt.execute(
+      {
+        task: "Some task",
+        max_subtasks: 5,
+        query_cass: false,
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed).toHaveProperty("expected_schema", "BeadTree");
+    expect(parsed).toHaveProperty("validation_note");
+    expect(parsed.validation_note).toContain("swarm_validate_decomposition");
+    expect(parsed).toHaveProperty("schema_hint");
+    expect(parsed.schema_hint).toHaveProperty("epic");
+    expect(parsed.schema_hint).toHaveProperty("subtasks");
+  });
+
+  it("reports CASS status in output (queried flag)", async () => {
+    // Test with CASS disabled
+    const resultDisabled = await swarm_plan_prompt.execute(
+      {
+        task: "Add feature",
+        max_subtasks: 3,
+        query_cass: false,
+      },
+      mockContext,
+    );
+    const parsedDisabled = JSON.parse(resultDisabled);
+
+    expect(parsedDisabled).toHaveProperty("cass_history");
+    expect(parsedDisabled.cass_history.queried).toBe(false);
+
+    // Test with CASS enabled (may or may not be available)
+    const resultEnabled = await swarm_plan_prompt.execute(
+      {
+        task: "Add feature",
+        max_subtasks: 3,
+        query_cass: true,
+      },
+      mockContext,
+    );
+    const parsedEnabled = JSON.parse(resultEnabled);
+
+    expect(parsedEnabled).toHaveProperty("cass_history");
+    expect(parsedEnabled.cass_history).toHaveProperty("queried");
+    // If CASS is unavailable, queried will be false with reason
+    if (!parsedEnabled.cass_history.queried) {
+      expect(parsedEnabled.cass_history).toHaveProperty("reason");
+    }
+  });
+
+  it("includes context in prompt when provided", async () => {
+    const result = await swarm_plan_prompt.execute(
+      {
+        task: "Add user profile",
+        max_subtasks: 3,
+        context: "We use Next.js App Router with server components",
+        query_cass: false,
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed.prompt).toContain("Next.js App Router");
+    expect(parsed.prompt).toContain("server components");
+  });
+
+  it("includes max_subtasks in prompt", async () => {
+    const result = await swarm_plan_prompt.execute(
+      {
+        task: "Build something",
+        max_subtasks: 7,
+        query_cass: false,
+      },
+      mockContext,
+    );
+    const parsed = JSON.parse(result);
+
+    expect(parsed.prompt).toContain("2-7 independent subtasks");
+  });
+});
+
 describe("swarm_validate_decomposition", () => {
   it("validates correct BeadTree", async () => {
     const validBeadTree = JSON.stringify({
@@ -959,10 +1243,12 @@ describe("Graceful Degradation", () => {
 // Coordinator-Centric Swarm Tools (V2)
 // ============================================================================
 
-describe("Coordinator-Centric Swarm Tools", () => {
+describe("Swarm Prompt V2 (with Agent Mail/Beads)", () => {
   describe("formatSubtaskPromptV2", () => {
     it("generates correct prompt with all fields", () => {
       const result = formatSubtaskPromptV2({
+        bead_id: "bd-123.1",
+        epic_id: "bd-123",
         subtask_title: "Add OAuth provider",
         subtask_description: "Configure Google OAuth in the auth config",
         files: ["src/auth/google.ts", "src/auth/config.ts"],
@@ -982,16 +1268,15 @@ describe("Coordinator-Centric Swarm Tools", () => {
       // Check shared context is included
       expect(result).toContain("We are using NextAuth.js v5");
 
-      // Check expected sections exist
-      expect(result).toContain("## Your Task");
-      expect(result).toContain("## Files to Modify");
-      expect(result).toContain("## Context");
-      expect(result).toContain("## Instructions");
-      expect(result).toContain("## When Complete");
+      // Check bead/epic IDs are substituted
+      expect(result).toContain("bd-123.1");
+      expect(result).toContain("bd-123");
     });
 
     it("handles missing optional fields", () => {
       const result = formatSubtaskPromptV2({
+        bead_id: "bd-456.1",
+        epic_id: "bd-456",
         subtask_title: "Simple task",
         subtask_description: "",
         files: [],
@@ -1004,16 +1289,16 @@ describe("Coordinator-Centric Swarm Tools", () => {
       expect(result).toContain("(see title)");
 
       // Check fallback for empty files
-      expect(result).toContain(
-        "(no specific files assigned - use your judgment)",
-      );
+      expect(result).toContain("(no specific files - use judgment)");
 
       // Check fallback for missing context
-      expect(result).toContain("(none provided)");
+      expect(result).toContain("(none)");
     });
 
     it("handles files with special characters", () => {
       const result = formatSubtaskPromptV2({
+        bead_id: "bd-789.1",
+        epic_id: "bd-789",
         subtask_title: "Handle paths",
         subtask_description: "Test file paths",
         files: [
@@ -1030,51 +1315,39 @@ describe("Coordinator-Centric Swarm Tools", () => {
   describe("SUBTASK_PROMPT_V2", () => {
     it("contains expected sections", () => {
       // Check all main sections are present in the template
-      expect(SUBTASK_PROMPT_V2).toContain("## Your Task");
+      expect(SUBTASK_PROMPT_V2).toContain("## Task");
       expect(SUBTASK_PROMPT_V2).toContain("{subtask_title}");
       expect(SUBTASK_PROMPT_V2).toContain("{subtask_description}");
 
-      expect(SUBTASK_PROMPT_V2).toContain("## Files to Modify");
+      expect(SUBTASK_PROMPT_V2).toContain("## Files");
       expect(SUBTASK_PROMPT_V2).toContain("{file_list}");
 
       expect(SUBTASK_PROMPT_V2).toContain("## Context");
       expect(SUBTASK_PROMPT_V2).toContain("{shared_context}");
 
-      expect(SUBTASK_PROMPT_V2).toContain("## Instructions");
-      expect(SUBTASK_PROMPT_V2).toContain("Read first");
-      expect(SUBTASK_PROMPT_V2).toContain("Plan your approach");
-      expect(SUBTASK_PROMPT_V2).toContain("Make the changes");
-      expect(SUBTASK_PROMPT_V2).toContain("Verify");
-
-      expect(SUBTASK_PROMPT_V2).toContain("## When Complete");
-      expect(SUBTASK_PROMPT_V2).toContain('"success"');
-      expect(SUBTASK_PROMPT_V2).toContain('"summary"');
-      expect(SUBTASK_PROMPT_V2).toContain('"files_modified"');
+      expect(SUBTASK_PROMPT_V2).toContain("## Workflow");
     });
 
-    it("does NOT contain Agent Mail instructions", () => {
-      // V2 prompt is for coordinator-centric model where subagents don't use Agent Mail
-      expect(SUBTASK_PROMPT_V2).not.toContain("Agent Mail");
-      expect(SUBTASK_PROMPT_V2).not.toContain("agentmail_");
-      expect(SUBTASK_PROMPT_V2).not.toContain("agent_name");
-      expect(SUBTASK_PROMPT_V2).not.toContain("send_message");
+    it("DOES contain Agent Mail instructions", () => {
+      // V2 prompt tells agents to USE Agent Mail
+      expect(SUBTASK_PROMPT_V2).toContain("Agent Mail");
+      expect(SUBTASK_PROMPT_V2).toContain("agentmail_send");
+      expect(SUBTASK_PROMPT_V2).toContain("thread_id");
     });
 
-    it("does NOT contain beads instructions", () => {
-      // V2 prompt is for coordinator-centric model where subagents don't manage beads
-      expect(SUBTASK_PROMPT_V2).not.toContain("bead_id");
-      expect(SUBTASK_PROMPT_V2).not.toContain("epic_id");
-      expect(SUBTASK_PROMPT_V2).not.toContain("bd update");
-      expect(SUBTASK_PROMPT_V2).not.toContain("bd close");
-      expect(SUBTASK_PROMPT_V2).not.toContain("swarm_progress");
-      expect(SUBTASK_PROMPT_V2).not.toContain("swarm_complete");
+    it("DOES contain beads instructions", () => {
+      // V2 prompt tells agents to USE beads
+      expect(SUBTASK_PROMPT_V2).toContain("{bead_id}");
+      expect(SUBTASK_PROMPT_V2).toContain("{epic_id}");
+      expect(SUBTASK_PROMPT_V2).toContain("beads_update");
+      expect(SUBTASK_PROMPT_V2).toContain("beads_create");
+      expect(SUBTASK_PROMPT_V2).toContain("swarm_complete");
     });
 
-    it("expects structured JSON response from subagent", () => {
-      // The prompt should instruct agents to return structured JSON
-      expect(SUBTASK_PROMPT_V2).toContain("```json");
-      expect(SUBTASK_PROMPT_V2).toContain('"success"');
-      expect(SUBTASK_PROMPT_V2).toContain('"blocker"');
+    it("instructs agents to communicate", () => {
+      expect(SUBTASK_PROMPT_V2).toContain("Never work silently");
+      expect(SUBTASK_PROMPT_V2).toContain("Report progress");
+      expect(SUBTASK_PROMPT_V2).toContain("coordinator");
     });
   });
 });