opencode-swarm-plugin 0.43.0 → 0.44.1

package/evals/lib/compaction-loader.ts

@@ -1,320 +0,0 @@
-/**
- * Compaction Data Loader
- *
- * Loads COMPACTION events from session JSONL files for use in evals.
- *
- * Features:
- * - Lazy loading with early termination for large datasets
- * - Filtering by compaction_type, sessionIds, and limit
- * - Graceful error handling (skips invalid lines)
- * - Type-safe with Zod validation
- *
- * @module compaction-loader
- */
-import * as fs from "node:fs";
-import { createInterface } from "node:readline";
-import * as path from "node:path";
-import type { CoordinatorEvent } from "../../src/eval-capture.js";
-import { CoordinatorEventSchema } from "../../src/eval-capture.js";
-
-/**
- * Compaction event - subset of CoordinatorEvent with event_type === "COMPACTION"
- */
-export type CompactionEvent = Extract<
-  CoordinatorEvent,
-  { event_type: "COMPACTION" }
->;
-
-/**
- * Compaction session - session with only COMPACTION events
- */
-export interface CompactionSession {
-  session_id: string;
-  epic_id: string;
-  start_time: string;
-  end_time: string;
-  events: CompactionEvent[];
-}
-
-/**
- * Load options
- */
-export interface LoadOptions {
-  /** Filter by compaction_type */
-  compaction_type?:
-    | "detection_complete"
-    | "prompt_generated"
-    | "context_injected"
-    | "resumption_started"
-    | "tool_call_tracked";
-  /** Filter by session IDs */
-  sessionIds?: string[];
-  /** Limit number of results */
-  limit?: number;
-}
-
-/**
- * Load COMPACTION events from session JSONL files
- *
- * Reads all .jsonl files in the session directory, parses events,
- * and returns only COMPACTION events matching the filters.
- *
- * @param sessionDir - Path to session directory (default: ~/.config/swarm-tools/sessions)
- * @param options - Filter options
- * @returns Array of compaction events
- *
- * @example
- * // Load all COMPACTION events
- * const events = await loadCompactionEvents("/path/to/sessions");
- *
- * @example
- * // Load only detection_complete events
- * const events = await loadCompactionEvents("/path/to/sessions", {
- *   compaction_type: "detection_complete",
- * });
- *
- * @example
- * // Load events from specific sessions
- * const events = await loadCompactionEvents("/path/to/sessions", {
- *   sessionIds: ["session-1", "session-2"],
- *   limit: 10,
- * });
- */
-export async function loadCompactionEvents(
-  sessionDir: string,
-  options?: LoadOptions,
-): Promise<CompactionEvent[]> {
-  const { compaction_type, sessionIds, limit } = options ?? {};
-
-  // Check if directory exists
-  if (!fs.existsSync(sessionDir)) {
-    return [];
-  }
-
-  let files: string[];
-  try {
-    // Read all .jsonl files
-    files = fs.readdirSync(sessionDir).filter((f) => f.endsWith(".jsonl"));
-  } catch (error) {
-    // Directory exists but can't be read - log and return empty
-    console.warn(`Failed to read session directory ${sessionDir}:`, error);
-    return [];
-  }
-
-  // Filter by sessionIds if provided
-  const targetFiles = sessionIds
-    ? files.filter((f) => sessionIds.includes(f.replace(".jsonl", "")))
-    : files;
-
-  const events: CompactionEvent[] = [];
-
-  for (const file of targetFiles) {
-    const filePath = path.join(sessionDir, file);
-
-    try {
-      // Stream large files line-by-line to avoid loading entire file into memory
-      const shouldStream = limit && limit < 100; // For small limits, streaming is overkill
-      
-      if (shouldStream) {
-        // Use streaming for better memory efficiency
-        const found = await loadFromFileStream(filePath, {
-          compaction_type,
-          remainingLimit: limit - events.length,
-        });
-        events.push(...found);
-      } else {
-        // For small files or no limit, read entire file (faster)
-        const content = fs.readFileSync(filePath, "utf-8");
-        const lines = content.trim().split("\n").filter(Boolean);
-
-        for (const line of lines) {
-          const event = parseLine(line);
-          if (event && event.event_type === "COMPACTION") {
-            // Filter by compaction_type if provided
-            if (!compaction_type || event.compaction_type === compaction_type) {
-              events.push(event);
-
-              // Apply limit early to avoid processing unnecessary files
-              if (limit && events.length >= limit) {
-                return events.slice(0, limit);
-              }
-            }
-          }
-        }
-      }
-
-      // Early termination if limit reached
-      if (limit && events.length >= limit) {
-        return events.slice(0, limit);
-      }
-    } catch (error) {
-      // Log file read errors but continue processing other files
-      console.warn(`Failed to read session file ${filePath}:`, error);
-    }
-  }
-
-  return limit ? events.slice(0, limit) : events;
-}
-
-/**
- * Parse a JSONL line into a CoordinatorEvent
- * 
- * @param line - JSONL line to parse
- * @returns Parsed and validated event, or null if invalid
- */
-function parseLine(line: string): CoordinatorEvent | null {
-  try {
-    const parsed = JSON.parse(line);
-    return CoordinatorEventSchema.parse(parsed);
-  } catch {
-    // Invalid JSON or failed validation - skip silently
-    return null;
-  }
-}
-
-/**
- * Load COMPACTION events from a file using streaming (for large files)
- * 
- * @param filePath - Path to session JSONL file
- * @param options - Filter options
- * @returns Array of matching compaction events
- */
-async function loadFromFileStream(
-  filePath: string,
-  options: {
-    compaction_type?: LoadOptions["compaction_type"];
-    remainingLimit?: number;
-  },
-): Promise<CompactionEvent[]> {
-  const { compaction_type, remainingLimit } = options;
-  const events: CompactionEvent[] = [];
-
-  const fileStream = fs.createReadStream(filePath, { encoding: "utf-8" });
-  const rl = createInterface({ input: fileStream, crlfDelay: Number.POSITIVE_INFINITY });
-
-  for await (const line of rl) {
-    const event = parseLine(line);
-    if (event && event.event_type === "COMPACTION") {
-      if (!compaction_type || event.compaction_type === compaction_type) {
-        events.push(event);
-
-        // Early termination for streaming
-        if (remainingLimit && events.length >= remainingLimit) {
-          rl.close();
-          fileStream.close();
-          break;
-        }
-      }
-    }
-  }
-
-  return events;
-}
-
-/**
- * Load COMPACTION sessions grouped by session_id
- *
- * Groups COMPACTION events by session_id and returns session metadata.
- *
- * @param sessionDir - Path to session directory
- * @param options - Filter options
- * @returns Array of compaction sessions
- *
- * @example
- * // Load all sessions with COMPACTION events
- * const sessions = await loadCompactionSessions("/path/to/sessions");
- *
- * @example
- * // Load sessions with specific compaction_type
- * const sessions = await loadCompactionSessions("/path/to/sessions", {
- *   compaction_type: "prompt_generated",
- * });
- */
-export async function loadCompactionSessions(
-  sessionDir: string,
-  options?: LoadOptions,
-): Promise<CompactionSession[]> {
-  const events = await loadCompactionEvents(sessionDir, options);
-
-  if (events.length === 0) {
-    return [];
-  }
-
-  // Group events by session_id
-  const sessionMap = new Map<string, CompactionEvent[]>();
-
-  for (const event of events) {
-    const existing = sessionMap.get(event.session_id);
-    if (existing) {
-      existing.push(event);
-    } else {
-      sessionMap.set(event.session_id, [event]);
-    }
-  }
-
-  // Build sessions with metadata
-  const sessions: CompactionSession[] = [];
-
-  for (const [sessionId, sessionEvents] of sessionMap.entries()) {
-    if (sessionEvents.length === 0) {
-      continue;
-    }
-
-    // Get epic_id from first event
-    const epicId = sessionEvents[0].epic_id;
-
-    // Get timestamps
-    const timestamps = sessionEvents.map((e) => new Date(e.timestamp).getTime());
-    const startTime = new Date(Math.min(...timestamps)).toISOString();
-    const endTime = new Date(Math.max(...timestamps)).toISOString();
-
-    sessions.push({
-      session_id: sessionId,
-      epic_id: epicId,
-      start_time: startTime,
-      end_time: endTime,
-      events: sessionEvents,
-    });
-  }
-
-  // Apply limit
-  return options?.limit ? sessions.slice(0, options.limit) : sessions;
-}
-
-/**
- * Load COMPACTION events from default session directory
- *
- * Convenience wrapper that uses the default ~/.config/swarm-tools/sessions directory.
- *
- * @param options - Filter options
- * @returns Array of compaction events
- *
- * @example
- * // Load recent compaction events
- * const events = await loadDefaultCompactionEvents({ limit: 10 });
- */
-export async function loadDefaultCompactionEvents(
-  options?: LoadOptions,
-): Promise<CompactionEvent[]> {
-  const { getSessionDir } = await import("../../src/eval-capture.js");
-  return loadCompactionEvents(getSessionDir(), options);
-}
-
-/**
- * Load COMPACTION sessions from default session directory
- *
- * Convenience wrapper that uses the default ~/.config/swarm-tools/sessions directory.
- *
- * @param options - Filter options
- * @returns Array of compaction sessions
- *
- * @example
- * // Load all compaction sessions
- * const sessions = await loadDefaultCompactionSessions();
- */
-export async function loadDefaultCompactionSessions(
-  options?: LoadOptions,
-): Promise<CompactionSession[]> {
-  const { getSessionDir } = await import("../../src/eval-capture.js");
-  return loadCompactionSessions(getSessionDir(), options);
-}

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);
-    });
-  });
-});