opencode-swarm-plugin 0.19.0 → 0.21.0

package/evals/swarm-decomposition.eval.ts

@@ -0,0 +1,112 @@
+/**
+ * Swarm Decomposition Quality Eval
+ *
+ * Tests the quality of task decomposition for swarm coordination.
+ * Uses real LLM calls via AI SDK + Vercel AI Gateway.
+ *
+ * Scorers evaluate:
+ * - Subtask independence (no file conflicts)
+ * - Complexity balance (even distribution)
+ * - Coverage completeness (all required files)
+ * - Instruction clarity (actionable descriptions)
+ *
+ * Run with: pnpm evalite evals/swarm-decomposition.eval.ts
+ *
+ * Requires: ANTHROPIC_API_KEY environment variable
+ */
+import { evalite } from "evalite";
+import {
+  subtaskIndependence,
+  coverageCompleteness,
+  instructionClarity,
+} from "./scorers/index.js";
+import { decompositionCases } from "./fixtures/decomposition-cases.js";
+import {
+  generateDecomposition,
+  formatDecompositionPrompt,
+  extractJson,
+} from "./lib/llm.js";
+import {
+  loadEvalCases,
+  hasRealEvalData,
+  getEvalDataSummary,
+} from "./lib/data-loader.js";
+
+// Determine project key from current directory
+const PROJECT_KEY = "opencode-swarm-plugin";
+const PROJECT_PATH = process.cwd();
+
+// Check if we have enough real data to use instead of fixtures
+const useRealData = await hasRealEvalData(PROJECT_KEY, 5, PROJECT_PATH);
+
+// Load data based on availability
+const evalCases = useRealData
+  ? await loadEvalCases(PROJECT_KEY, { limit: 20, projectPath: PROJECT_PATH })
+  : decompositionCases.map((testCase) => ({
+      input: testCase.input,
+      expected: testCase.expected,
+    }));
+
+// Log data source for transparency
+if (useRealData) {
+  const summary = await getEvalDataSummary(PROJECT_KEY, PROJECT_PATH);
+  console.log(`[eval] Using real data from PGlite:`);
+  console.log(`  - Total records: ${summary.totalRecords}`);
+  console.log(`  - Success rate: ${(summary.successRate * 100).toFixed(1)}%`);
+  console.log(
+    `  - Strategies: ${Object.entries(summary.byStrategy)
+      .map(([s, c]) => `${s}(${c})`)
+      .join(", ")}`,
+  );
+  console.log(`  - Eval cases: ${evalCases.length}`);
+} else {
+  console.log(
+    `[eval] Using fixture data (${evalCases.length} cases) - not enough real data yet`,
+  );
+}
+
+/**
+ * Swarm Decomposition Quality Eval
+ *
+ * Tests decomposition quality with real LLM calls.
+ */
+evalite("Swarm Decomposition Quality", {
+  // Test data from PGlite or fixtures
+  data: async () => evalCases,
+
+  // Task: generate real decomposition via Claude
+  task: async (input) => {
+    const prompt = formatDecompositionPrompt(input.task, input.context);
+    const response = await generateDecomposition(prompt);
+    return extractJson(response);
+  },
+
+  // Scorers evaluate decomposition quality
+  scorers: [subtaskIndependence, coverageCompleteness, instructionClarity],
+});
+
+/**
+ * Edge Case Eval: Minimal and Complex Tasks
+ *
+ * Tests handling of edge cases in decomposition.
+ */
+evalite("Decomposition Edge Cases", {
+  data: async () => [
+    {
+      input: { task: "Fix typo in README.md" },
+      expected: { minSubtasks: 1, maxSubtasks: 2 },
+    },
+    {
+      input: { task: "Refactor entire codebase from JavaScript to TypeScript" },
+      expected: { minSubtasks: 4, maxSubtasks: 8 },
+    },
+  ],
+
+  task: async (input) => {
+    const prompt = formatDecompositionPrompt(input.task, undefined, 8);
+    const response = await generateDecomposition(prompt);
+    return extractJson(response);
+  },
+
+  scorers: [subtaskIndependence, coverageCompleteness],
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "dist/index.js",
@@ -27,6 +27,9 @@
     "test:all": "bun run test && bun run test:swarm",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist",
+    "eval:dev": "evalite watch evals/",
+    "eval:run": "evalite run evals/",
+    "eval:ci": "evalite run evals/ --threshold 80",
     "release": "npm run build && npm version patch && git push && npm run publish:otp",
     "release:minor": "npm run build && npm version minor && git push && npm run publish:otp",
     "release:major": "npm run build && npm version major && git push && npm run publish:otp",
@@ -41,11 +44,15 @@
     "gray-matter": "^4.0.3",
     "ioredis": "^5.4.1",
     "minimatch": "^10.1.1",
+    "nanoid": "^5.1.6",
     "zod": "4.1.8"
   },
   "devDependencies": {
     "@types/bun": "latest",
     "@types/minimatch": "^6.0.0",
+    "ai": "6.0.0-beta.150",
+    "bun-types": "^1.3.4",
+    "evalite": "^1.0.0-beta.10",
     "typescript": "^5.7.0",
     "vitest": "^4.0.15"
   },

package/src/agent-mail.ts

@@ -31,6 +31,7 @@ import { tool } from "@opencode-ai/plugin";
 import { z } from "zod";
 import { isToolAvailable, warnMissingTool } from "./tool-availability";
 import { getRateLimiter, type RateLimiter } from "./rate-limiter";
+import type { MailSessionState } from "./streams/events";
 
 // ============================================================================
 // Configuration
@@ -92,13 +93,12 @@ const RECOVERY_CONFIG = {
 // Types
 // ============================================================================
 
-/** Agent Mail session state */
-export interface AgentMailState {
-  projectKey: string;
-  agentName: string;
-  reservations: number[];
-  startedAt: string;
-}
+/**
+ * Agent Mail session state
+ * @deprecated Use MailSessionState from streams/events.ts instead
+ * This is kept for backward compatibility and re-exported as an alias
+ */
+export type AgentMailState = MailSessionState;
 
 // ============================================================================
 // Module-level state (keyed by sessionID)

package/src/beads.ts

@@ -104,6 +104,8 @@ import {
   type BeadCreateArgs,
   type EpicCreateResult,
 } from "./schemas";
+import { createEvent } from "./streams/events";
+import { appendEvent } from "./streams/store";
 
 /**
  * Custom error for bead operations
@@ -321,6 +323,26 @@ export const beads_create_epic = tool({
         }),
       )
       .describe("Subtasks to create under the epic"),
+    strategy: tool.schema
+      .enum(["file-based", "feature-based", "risk-based"])
+      .optional()
+      .describe("Decomposition strategy used (default: feature-based)"),
+    task: tool.schema
+      .string()
+      .optional()
+      .describe("Original task description that was decomposed"),
+    project_key: tool.schema
+      .string()
+      .optional()
+      .describe("Project path for event emission"),
+    recovery_context: tool.schema
+      .object({
+        shared_context: tool.schema.string().optional(),
+        skills_to_load: tool.schema.array(tool.schema.string()).optional(),
+        coordinator_notes: tool.schema.string().optional(),
+      })
+      .optional()
+      .describe("Recovery context from checkpoint compaction"),
   },
   async execute(args, ctx) {
     const validated = EpicCreateArgsSchema.parse(args);
@@ -386,6 +408,33 @@ export const beads_create_epic = tool({
         subtasks: created.slice(1),
       };
 
+      // Emit DecompositionGeneratedEvent for learning system
+      if (args.project_key) {
+        try {
+          const event = createEvent("decomposition_generated", {
+            project_key: args.project_key,
+            epic_id: epic.id,
+            task: args.task || validated.epic_title,
+            context: validated.epic_description,
+            strategy: args.strategy || "feature-based",
+            epic_title: validated.epic_title,
+            subtasks: validated.subtasks.map((st) => ({
+              title: st.title,
+              files: st.files || [],
+              priority: st.priority,
+            })),
+            recovery_context: args.recovery_context,
+          });
+          await appendEvent(event, args.project_key);
+        } catch (error) {
+          // Non-fatal - log and continue
+          console.warn(
+            "[beads_create_epic] Failed to emit DecompositionGeneratedEvent:",
+            error,
+          );
+        }
+      }
+
       return JSON.stringify(result, null, 2);
     } catch (error) {
       // Partial failure - execute rollback automatically