opencode-swarm-plugin 0.44.0 → 0.44.2

package/evals/lib/data-loader.evalite-test.ts

@@ -1,289 +0,0 @@
-/**
- * Data Loader Tests
- *
- * Tests the PGlite-backed eval data loader functions.
- * Uses a real in-memory PGlite database for accurate testing.
- */
-import { describe, it, expect, beforeAll, afterAll } from "bun:test";
-import {
-  loadEvalCases,
-  hasRealEvalData,
-  getEvalDataSummary,
-} from "./data-loader.js";
-import {
-  appendEvent,
-  getDatabase,
-  closeDatabase,
-  type DecompositionGeneratedEvent,
-  type SubtaskOutcomeEvent,
-} from "swarm-mail";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-
-const TEST_PROJECT_KEY = "test-project-eval-loader";
-
-// Create a unique temp directory for this test run
-let testDir: string;
-
-describe("Data Loader", () => {
-  beforeAll(async () => {
-    // Create temp directory for test database
-    testDir = fs.mkdtempSync(path.join(os.tmpdir(), "eval-loader-test-"));
-
-    // Initialize database by getting it (lazy init)
-    await getDatabase(testDir);
-  });
-
-  afterAll(async () => {
-    await closeDatabase(testDir);
-    // Clean up temp directory
-    fs.rmSync(testDir, { recursive: true, force: true });
-  });
-
-  describe("loadEvalCases", () => {
-    it("transforms eval records to EvalCase format", async () => {
-      // Insert a decomposition event
-      const decompositionEvent: DecompositionGeneratedEvent = {
-        type: "decomposition_generated",
-        timestamp: Date.now(),
-        project_key: TEST_PROJECT_KEY,
-        epic_id: "epic-load-1",
-        task: "Add authentication",
-        context: "Next.js app",
-        strategy: "feature-based",
-        epic_title: "Auth Epic",
-        subtasks: [
-          { title: "OAuth setup", files: ["src/auth/oauth.ts"], priority: 1 },
-          {
-            title: "Session management",
-            files: ["src/auth/session.ts"],
-            priority: 2,
-          },
-        ],
-      };
-      await appendEvent(decompositionEvent, testDir);
-
-      // Insert outcome events for both subtasks
-      const outcome1: SubtaskOutcomeEvent = {
-        type: "subtask_outcome",
-        timestamp: Date.now(),
-        project_key: TEST_PROJECT_KEY,
-        epic_id: "epic-load-1",
-        bead_id: "epic-load-1.1",
-        planned_files: ["src/auth/oauth.ts"],
-        actual_files: ["src/auth/oauth.ts"],
-        duration_ms: 5000,
-        error_count: 0,
-        retry_count: 0,
-        success: true,
-      };
-      await appendEvent(outcome1, testDir);
-
-      const outcome2: SubtaskOutcomeEvent = {
-        type: "subtask_outcome",
-        timestamp: Date.now(),
-        project_key: TEST_PROJECT_KEY,
-        epic_id: "epic-load-1",
-        bead_id: "epic-load-1.2",
-        planned_files: ["src/auth/session.ts"],
-        actual_files: ["src/auth/session.ts"],
-        duration_ms: 3000,
-        error_count: 0,
-        retry_count: 0,
-        success: true,
-      };
-      await appendEvent(outcome2, testDir);
-
-      const cases = await loadEvalCases(TEST_PROJECT_KEY, {
-        projectPath: testDir,
-      });
-
-      expect(cases.length).toBeGreaterThanOrEqual(1);
-      const authCase = cases.find((c) => c.input.task === "Add authentication");
-      expect(authCase).toBeDefined();
-      expect(authCase!.input.context).toBe("Next.js app");
-      expect(authCase!.expected.minSubtasks).toBe(2);
-      expect(authCase!.expected.maxSubtasks).toBe(2);
-      expect(authCase!.expected.requiredFiles).toContain("src/auth/oauth.ts");
-      expect(authCase!.expected.requiredFiles).toContain("src/auth/session.ts");
-      expect(authCase!.actual).toBeDefined();
-    });
-
-    it("filters by success when successOnly is true", async () => {
-      // Insert a successful decomposition
-      const successEvent: DecompositionGeneratedEvent = {
-        type: "decomposition_generated",
-        timestamp: Date.now(),
-        project_key: TEST_PROJECT_KEY,
-        epic_id: "epic-success-filter",
-        task: "Success task for filter",
-        strategy: "feature-based",
-        epic_title: "Success Epic",
-        subtasks: [{ title: "Sub", files: ["src/success.ts"], priority: 1 }],
-      };
-      await appendEvent(successEvent, testDir);
-
-      // Mark it successful
-      const successOutcome: SubtaskOutcomeEvent = {
-        type: "subtask_outcome",
-        timestamp: Date.now(),
-        project_key: TEST_PROJECT_KEY,
-        epic_id: "epic-success-filter",
-        bead_id: "epic-success-filter.1",
-        planned_files: ["src/success.ts"],
-        actual_files: ["src/success.ts"],
-        duration_ms: 1000,
-        error_count: 0,
-        retry_count: 0,
-        success: true,
-      };
-      await appendEvent(successOutcome, testDir);
-
-      // Insert a failed decomposition
-      const failEvent: DecompositionGeneratedEvent = {
-        type: "decomposition_generated",
-        timestamp: Date.now(),
-        project_key: TEST_PROJECT_KEY,
-        epic_id: "epic-fail-filter",
-        task: "Failed task for filter",
-        strategy: "feature-based",
-        epic_title: "Failed Epic",
-        subtasks: [{ title: "Sub", files: ["src/fail.ts"], priority: 1 }],
-      };
-      await appendEvent(failEvent, testDir);
-
-      // Mark it failed
-      const failOutcome: SubtaskOutcomeEvent = {
-        type: "subtask_outcome",
-        timestamp: Date.now(),
-        project_key: TEST_PROJECT_KEY,
-        epic_id: "epic-fail-filter",
-        bead_id: "epic-fail-filter.1",
-        planned_files: ["src/fail.ts"],
-        actual_files: [],
-        duration_ms: 500,
-        error_count: 3,
-        retry_count: 2,
-        success: false,
-      };
-      await appendEvent(failOutcome, testDir);
-
-      const successCases = await loadEvalCases(TEST_PROJECT_KEY, {
-        successOnly: true,
-        projectPath: testDir,
-      });
-
-      // Should only include successful cases
-      const failedCase = successCases.find(
-        (c) => c.input.task === "Failed task for filter",
-      );
-      expect(failedCase).toBeUndefined();
-    });
-
-    it("passes strategy filter to getEvalRecords", async () => {
-      // Insert file-based decomposition
-      const fileBasedEvent: DecompositionGeneratedEvent = {
-        type: "decomposition_generated",
-        timestamp: Date.now(),
-        project_key: TEST_PROJECT_KEY,
-        epic_id: "epic-file-based",
-        task: "File-based task",
-        strategy: "file-based",
-        epic_title: "File Epic",
-        subtasks: [{ title: "Sub", files: ["src/file.ts"], priority: 1 }],
-      };
-      await appendEvent(fileBasedEvent, testDir);
-
-      const fileBasedCases = await loadEvalCases(TEST_PROJECT_KEY, {
-        strategy: "file-based",
-        projectPath: testDir,
-      });
-
-      // All returned cases should be file-based
-      for (const c of fileBasedCases) {
-        expect(c.actual?.strategy).toBe("file-based");
-      }
-    });
-
-    it("passes limit to getEvalRecords", async () => {
-      const cases = await loadEvalCases(TEST_PROJECT_KEY, {
-        limit: 2,
-        projectPath: testDir,
-      });
-
-      expect(cases.length).toBeLessThanOrEqual(2);
-    });
-
-    it("handles records with no context", async () => {
-      const noContextEvent: DecompositionGeneratedEvent = {
-        type: "decomposition_generated",
-        timestamp: Date.now(),
-        project_key: TEST_PROJECT_KEY,
-        epic_id: "epic-no-context",
-        task: "Task without context",
-        // context is undefined
-        strategy: "feature-based",
-        epic_title: "No Context Epic",
-        subtasks: [{ title: "Sub", files: [], priority: 1 }],
-      };
-      await appendEvent(noContextEvent, testDir);
-
-      const cases = await loadEvalCases(TEST_PROJECT_KEY, {
-        projectPath: testDir,
-      });
-      const noContextCase = cases.find(
-        (c) => c.input.task === "Task without context",
-      );
-
-      expect(noContextCase).toBeDefined();
-      expect(noContextCase!.input.context).toBeUndefined();
-    });
-  });
-
-  describe("hasRealEvalData", () => {
-    it("returns true when enough records exist", async () => {
-      // We've inserted several records above, should have enough
-      const hasData = await hasRealEvalData(TEST_PROJECT_KEY, 1, testDir);
-      expect(hasData).toBe(true);
-    });
-
-    it("returns false when not enough records exist", async () => {
-      // Use a project key with no data
-      const hasData = await hasRealEvalData("nonexistent-project", 5, testDir);
-      expect(hasData).toBe(false);
-    });
-
-    it("uses custom minRecords threshold", async () => {
-      // Should have at least 1 record
-      const hasData = await hasRealEvalData(TEST_PROJECT_KEY, 1, testDir);
-      expect(hasData).toBe(true);
-
-      // Should not have 1000 records
-      const hasLotsOfData = await hasRealEvalData(
-        TEST_PROJECT_KEY,
-        1000,
-        testDir,
-      );
-      expect(hasLotsOfData).toBe(false);
-    });
-  });
-
-  describe("getEvalDataSummary", () => {
-    it("returns formatted summary with hasEnoughData flag", async () => {
-      const summary = await getEvalDataSummary(TEST_PROJECT_KEY, testDir);
-
-      expect(summary.totalRecords).toBeGreaterThanOrEqual(1);
-      expect(typeof summary.successRate).toBe("number");
-      expect(typeof summary.byStrategy).toBe("object");
-      expect(typeof summary.hasEnoughData).toBe("boolean");
-    });
-
-    it("sets hasEnoughData based on record count", async () => {
-      // Empty project should not have enough data
-      const emptySummary = await getEvalDataSummary("empty-project", testDir);
-      expect(emptySummary.hasEnoughData).toBe(false);
-      expect(emptySummary.totalRecords).toBe(0);
-    });
-  });
-});

package/evals/lib/data-loader.test.ts

@@ -1,345 +0,0 @@
-/**
- * Tests for data-loader quality filters
- *
- * TDD approach: RED → GREEN → REFACTOR
- */
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import type { CoordinatorEvent } from "../../src/eval-capture.js";
-import { loadCapturedSessions } from "./data-loader.js";
-
-// Test helper: create a temp session directory
-let tempSessionDir: string;
-
-beforeEach(() => {
-  tempSessionDir = fs.mkdtempSync(path.join(os.tmpdir(), "test-sessions-"));
-});
-
-afterEach(() => {
-  if (fs.existsSync(tempSessionDir)) {
-    fs.rmSync(tempSessionDir, { recursive: true });
-  }
-});
-
-/**
- * Helper: create a session JSONL file with events
- */
-function createSessionFile(
-  sessionId: string,
-  events: CoordinatorEvent[],
-): void {
-  const filePath = path.join(tempSessionDir, `${sessionId}.jsonl`);
-  const lines = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  fs.writeFileSync(filePath, lines, "utf-8");
-}
-
-/**
- * Helper: create minimal events
- */
-function createEvent(
-  sessionId: string,
-  epicId: string,
-  type: "DECISION" | "VIOLATION" | "OUTCOME",
-  subtype: string,
-): CoordinatorEvent {
-  const base = {
-    session_id: sessionId,
-    epic_id: epicId,
-    timestamp: new Date().toISOString(),
-    payload: {},
-  };
-
-  if (type === "DECISION") {
-    return {
-      ...base,
-      event_type: "DECISION" as const,
-      decision_type: subtype as any,
-    };
-  } else if (type === "VIOLATION") {
-    return {
-      ...base,
-      event_type: "VIOLATION" as const,
-      violation_type: subtype as any,
-    };
-  } else {
-    return {
-      ...base,
-      event_type: "OUTCOME" as const,
-      outcome_type: subtype as any,
-    };
-  }
-}
-
-describe("loadCapturedSessions - quality filters", () => {
-  test("filters out sessions with fewer than minEvents (default: 3)", async () => {
-    // Create sessions with different event counts
-    createSessionFile("session-2-events", [
-      createEvent("session-2-events", "epic-1", "DECISION", "worker_spawned"),
-      createEvent("session-2-events", "epic-1", "OUTCOME", "subtask_success"),
-    ]);
-
-    createSessionFile("session-3-events", [
-      createEvent("session-3-events", "epic-2", "DECISION", "worker_spawned"),
-      createEvent("session-3-events", "epic-2", "DECISION", "review_completed"),
-      createEvent("session-3-events", "epic-2", "OUTCOME", "subtask_success"),
-    ]);
-
-    createSessionFile("session-5-events", [
-      createEvent("session-5-events", "epic-3", "DECISION", "worker_spawned"),
-      createEvent("session-5-events", "epic-3", "DECISION", "review_completed"),
-      createEvent("session-5-events", "epic-3", "OUTCOME", "subtask_success"),
-      createEvent("session-5-events", "epic-3", "OUTCOME", "subtask_success"),
-      createEvent("session-5-events", "epic-3", "OUTCOME", "epic_complete"),
-    ]);
-
-    const sessions = await loadCapturedSessions({
-      minEvents: 3,
-      sessionDir: tempSessionDir,
-    });
-
-    // Should only get sessions with >= 3 events
-    expect(sessions.length).toBe(2);
-    expect(
-      sessions.some((s) => s.session.session_id === "session-3-events"),
-    ).toBe(true);
-    expect(
-      sessions.some((s) => s.session.session_id === "session-5-events"),
-    ).toBe(true);
-    expect(
-      sessions.some((s) => s.session.session_id === "session-2-events"),
-    ).toBe(false);
-  });
-
-  test("filters out sessions without worker_spawned event when requireWorkerSpawn=true", async () => {
-    // Session WITH worker_spawned
-    createSessionFile("session-with-spawn", [
-      createEvent("session-with-spawn", "epic-1", "DECISION", "worker_spawned"),
-      createEvent(
-        "session-with-spawn",
-        "epic-1",
-        "DECISION",
-        "review_completed",
-      ),
-      createEvent("session-with-spawn", "epic-1", "OUTCOME", "subtask_success"),
-    ]);
-
-    // Session WITHOUT worker_spawned
-    createSessionFile("session-no-spawn", [
-      createEvent(
-        "session-no-spawn",
-        "epic-2",
-        "DECISION",
-        "strategy_selected",
-      ),
-      createEvent(
-        "session-no-spawn",
-        "epic-2",
-        "DECISION",
-        "decomposition_complete",
-      ),
-      createEvent("session-no-spawn", "epic-2", "OUTCOME", "epic_complete"),
-    ]);
-
-    const sessions = await loadCapturedSessions({
-      requireWorkerSpawn: true,
-      sessionDir: tempSessionDir,
-    });
-
-    expect(sessions.length).toBe(1);
-    expect(sessions[0]?.session.session_id).toBe("session-with-spawn");
-  });
-
-  test("filters out sessions without review_completed event when requireReview=true", async () => {
-    // Session WITH review
-    createSessionFile("session-with-review", [
-      createEvent(
-        "session-with-review",
-        "epic-1",
-        "DECISION",
-        "worker_spawned",
-      ),
-      createEvent(
-        "session-with-review",
-        "epic-1",
-        "DECISION",
-        "review_completed",
-      ),
-      createEvent("session-with-review", "epic-1", "OUTCOME", "subtask_success"),
-    ]);
-
-    // Session WITHOUT review
-    createSessionFile("session-no-review", [
-      createEvent("session-no-review", "epic-2", "DECISION", "worker_spawned"),
-      createEvent("session-no-review", "epic-2", "OUTCOME", "subtask_success"),
-      createEvent("session-no-review", "epic-2", "OUTCOME", "epic_complete"),
-    ]);
-
-    const sessions = await loadCapturedSessions({
-      requireReview: true,
-      sessionDir: tempSessionDir,
-    });
-
-    expect(sessions.length).toBe(1);
-    expect(sessions[0]?.session.session_id).toBe("session-with-review");
-  });
-
-  test("allows disabling filters individually", async () => {
-    // Session with only 2 events, no worker_spawned, no review
-    createSessionFile("session-low-quality", [
-      createEvent(
-        "session-low-quality",
-        "epic-1",
-        "DECISION",
-        "strategy_selected",
-      ),
-      createEvent("session-low-quality", "epic-1", "OUTCOME", "epic_complete"),
-    ]);
-
-    // Disable all filters
-    const sessions = await loadCapturedSessions({
-      minEvents: 0,
-      requireWorkerSpawn: false,
-      requireReview: false,
-      sessionDir: tempSessionDir,
-    });
-
-    expect(sessions.length).toBe(1);
-    expect(sessions[0]?.session.session_id).toBe("session-low-quality");
-  });
-
-  test("applies limit AFTER filtering", async () => {
-    // Create 5 high-quality sessions
-    for (let i = 1; i <= 5; i++) {
-      createSessionFile(`session-${i}`, [
-        createEvent(`session-${i}`, `epic-${i}`, "DECISION", "worker_spawned"),
-        createEvent(
-          `session-${i}`,
-          `epic-${i}`,
-          "DECISION",
-          "review_completed",
-        ),
-        createEvent(`session-${i}`, `epic-${i}`, "OUTCOME", "subtask_success"),
-      ]);
-    }
-
-    // Create 3 low-quality sessions (will be filtered out)
-    for (let i = 6; i <= 8; i++) {
-      createSessionFile(`session-${i}`, [
-        createEvent(`session-${i}`, `epic-${i}`, "DECISION", "strategy_selected"),
-      ]);
-    }
-
-    // Filter first (remove 3 low-quality), then limit to 2
-    const sessions = await loadCapturedSessions({
-      minEvents: 3,
-      requireWorkerSpawn: true,
-      requireReview: true,
-      limit: 2,
-      sessionDir: tempSessionDir,
-    });
-
-    // Should get 2 sessions from the 5 high-quality ones
-    expect(sessions.length).toBe(2);
-    expect(sessions.every((s) => s.session.events.length >= 3)).toBe(true);
-  });
-
-  test("combines all filters correctly", async () => {
-    // High-quality session (passes all filters)
-    createSessionFile("session-high-quality", [
-      createEvent(
-        "session-high-quality",
-        "epic-1",
-        "DECISION",
-        "worker_spawned",
-      ),
-      createEvent(
-        "session-high-quality",
-        "epic-1",
-        "DECISION",
-        "review_completed",
-      ),
-      createEvent("session-high-quality", "epic-1", "OUTCOME", "subtask_success"),
-      createEvent("session-high-quality", "epic-1", "OUTCOME", "epic_complete"),
-    ]);
-
-    // Missing worker_spawned
-    createSessionFile("session-no-spawn", [
-      createEvent(
-        "session-no-spawn",
-        "epic-2",
-        "DECISION",
-        "review_completed",
-      ),
-      createEvent("session-no-spawn", "epic-2", "OUTCOME", "subtask_success"),
-      createEvent("session-no-spawn", "epic-2", "OUTCOME", "epic_complete"),
-    ]);
-
-    // Missing review_completed
-    createSessionFile("session-no-review", [
-      createEvent("session-no-review", "epic-3", "DECISION", "worker_spawned"),
-      createEvent("session-no-review", "epic-3", "OUTCOME", "subtask_success"),
-      createEvent("session-no-review", "epic-3", "OUTCOME", "epic_complete"),
-    ]);
-
-    // Too few events
-    createSessionFile("session-too-few", [
-      createEvent("session-too-few", "epic-4", "DECISION", "worker_spawned"),
-      createEvent("session-too-few", "epic-4", "DECISION", "review_completed"),
-    ]);
-
-    const sessions = await loadCapturedSessions({
-      minEvents: 3,
-      requireWorkerSpawn: true,
-      requireReview: true,
-      sessionDir: tempSessionDir,
-    });
-
-    // Only high-quality session should pass
-    expect(sessions.length).toBe(1);
-    expect(sessions[0]?.session.session_id).toBe("session-high-quality");
-  });
-
-  test("defaults are: minEvents=3, requireWorkerSpawn=true, requireReview=true", async () => {
-    // Create one session that meets defaults
-    createSessionFile("session-meets-defaults", [
-      createEvent(
-        "session-meets-defaults",
-        "epic-1",
-        "DECISION",
-        "worker_spawned",
-      ),
-      createEvent(
-        "session-meets-defaults",
-        "epic-1",
-        "DECISION",
-        "review_completed",
-      ),
-      createEvent(
-        "session-meets-defaults",
-        "epic-1",
-        "OUTCOME",
-        "subtask_success",
-      ),
-    ]);
-
-    // Create one that doesn't
-    createSessionFile("session-fails-defaults", [
-      createEvent(
-        "session-fails-defaults",
-        "epic-2",
-        "DECISION",
-        "strategy_selected",
-      ),
-    ]);
-
-    // Call with NO options except sessionDir - should use defaults
-    const sessions = await loadCapturedSessions({
-      sessionDir: tempSessionDir,
-    });
-
-    expect(sessions.length).toBe(1);
-    expect(sessions[0]?.session.session_id).toBe("session-meets-defaults");
-  });
-});