opencode-swarm-plugin 0.44.0 → 0.44.2

package/evals/fixtures/decomposition-cases.ts

@@ -1,105 +0,0 @@
-/**
- * Test cases for swarm task decomposition
- *
- * Each case includes:
- * - input: task description and optional context
- * - expected: validation criteria (min/max subtasks, required files)
- */
-
-export interface DecompositionTestCase {
-  input: {
-    task: string;
-    context?: string;
-  };
-  expected: {
-    minSubtasks: number;
-    maxSubtasks: number;
-    requiredFiles?: string[];
-  };
-}
-
-export const decompositionCases: DecompositionTestCase[] = [
-  {
-    input: {
-      task: "Add user authentication with OAuth",
-      context: "Next.js App Router application with existing user model",
-    },
-    expected: {
-      minSubtasks: 3,
-      maxSubtasks: 6,
-      requiredFiles: [
-        "src/auth/oauth.ts",
-        "src/auth/middleware.ts",
-        "app/api/auth/[...nextauth]/route.ts",
-      ],
-    },
-  },
-  {
-    input: {
-      task: "Implement rate limiting for API endpoints",
-      context: "Express.js API with Redis available",
-    },
-    expected: {
-      minSubtasks: 2,
-      maxSubtasks: 4,
-      requiredFiles: [
-        "src/middleware/rate-limit.ts",
-        "src/utils/redis-client.ts",
-      ],
-    },
-  },
-  {
-    input: {
-      task: "Add TypeScript strict mode to legacy JavaScript project",
-      context: "Large codebase with 50+ JS files, currently untyped",
-    },
-    expected: {
-      minSubtasks: 4,
-      maxSubtasks: 8,
-      requiredFiles: ["tsconfig.json"],
-    },
-  },
-  {
-    input: {
-      task: "Create admin dashboard for user management",
-      context: "React app with existing component library and API client",
-    },
-    expected: {
-      minSubtasks: 4,
-      maxSubtasks: 7,
-      requiredFiles: [
-        "src/pages/admin/Dashboard.tsx",
-        "src/components/admin/UserTable.tsx",
-        "src/api/admin.ts",
-      ],
-    },
-  },
-  {
-    input: {
-      task: "Fix memory leak in long-running background job",
-      context:
-        "Node.js worker that processes queue messages, memory grows over time",
-    },
-    expected: {
-      minSubtasks: 2,
-      maxSubtasks: 4,
-      requiredFiles: ["src/workers/queue-processor.ts"],
-    },
-  },
-  {
-    input: {
-      task: "Implement feature flag system with remote config",
-      context:
-        "Microservices architecture, need runtime toggles without deploys",
-    },
-    expected: {
-      minSubtasks: 3,
-      maxSubtasks: 6,
-      requiredFiles: [
-        "src/feature-flags/client.ts",
-        "src/feature-flags/middleware.ts",
-        "src/feature-flags/types.ts",
-      ],
-    },
-  },
-];

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

@@ -1,248 +0,0 @@
-/**
- * Compaction Data Loader Tests
- *
- * Tests loading COMPACTION events from session JSONL files.
- */
-import { afterAll, beforeAll, 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 {
-  loadCompactionEvents,
-  loadCompactionSessions,
-} from "./compaction-loader.js";
-
-// Test fixtures directory
-const TEST_SESSION_DIR = path.join(
-  os.tmpdir(),
-  `test-sessions-${Date.now()}`,
-);
-
-/**
- * Create a test session JSONL file
- */
-function createSessionFile(
-  sessionId: string,
-  events: CoordinatorEvent[],
-): void {
-  const sessionPath = path.join(TEST_SESSION_DIR, `${sessionId}.jsonl`);
-  const lines = events.map((e) => JSON.stringify(e)).join("\n");
-  fs.writeFileSync(sessionPath, `${lines}\n`, "utf-8");
-}
-
-beforeAll(() => {
-  // Create test session directory
-  fs.mkdirSync(TEST_SESSION_DIR, { recursive: true });
-
-  // Create test session files with COMPACTION events
-  createSessionFile("session-1", [
-    {
-      session_id: "session-1",
-      epic_id: "epic-1",
-      timestamp: "2025-01-01T10:00:00.000Z",
-      event_type: "DECISION",
-      decision_type: "decomposition_complete",
-      payload: { subtask_count: 3 },
-    },
-    {
-      session_id: "session-1",
-      epic_id: "epic-1",
-      timestamp: "2025-01-01T10:05:00.000Z",
-      event_type: "COMPACTION",
-      compaction_type: "detection_complete",
-      payload: {
-        confidence: "high",
-        context_type: "full",
-        epic_id: "epic-1",
-      },
-    },
-    {
-      session_id: "session-1",
-      epic_id: "epic-1",
-      timestamp: "2025-01-01T10:06:00.000Z",
-      event_type: "COMPACTION",
-      compaction_type: "prompt_generated",
-      payload: {
-        prompt_length: 5000,
-        full_prompt: "You are a coordinator...",
-        context_type: "full",
-      },
-    },
-  ]);
-
-  createSessionFile("session-2", [
-    {
-      session_id: "session-2",
-      epic_id: "epic-2",
-      timestamp: "2025-01-02T10:00:00.000Z",
-      event_type: "COMPACTION",
-      compaction_type: "context_injected",
-      payload: {
-        injection_point: "tool_call",
-        context_length: 3000,
-      },
-    },
-    {
-      session_id: "session-2",
-      epic_id: "epic-2",
-      timestamp: "2025-01-02T10:01:00.000Z",
-      event_type: "COMPACTION",
-      compaction_type: "resumption_started",
-      payload: {
-        epic_id: "epic-2",
-        resumption_type: "coordinator",
-      },
-    },
-  ]);
-
-  // Session with no COMPACTION events
-  createSessionFile("session-3", [
-    {
-      session_id: "session-3",
-      epic_id: "epic-3",
-      timestamp: "2025-01-03T10:00:00.000Z",
-      event_type: "DECISION",
-      decision_type: "worker_spawned",
-      payload: { worker: "BlueLake", bead_id: "epic-3.1" },
-    },
-  ]);
-});
-
-afterAll(() => {
-  // Clean up test session directory
-  if (fs.existsSync(TEST_SESSION_DIR)) {
-    fs.rmSync(TEST_SESSION_DIR, { recursive: true });
-  }
-});
-
-describe("loadCompactionEvents", () => {
-  test("loads all COMPACTION events from session directory", async () => {
-    const events = await loadCompactionEvents(TEST_SESSION_DIR);
-
-    expect(events.length).toBe(4);
-    expect(events.every((e) => e.event_type === "COMPACTION")).toBe(true);
-  });
-
-  test("filters by compaction_type", async () => {
-    const events = await loadCompactionEvents(TEST_SESSION_DIR, {
-      compaction_type: "detection_complete",
-    });
-
-    expect(events.length).toBe(1);
-    expect(events[0].compaction_type).toBe("detection_complete");
-  });
-
-  test("filters by session_ids", async () => {
-    const events = await loadCompactionEvents(TEST_SESSION_DIR, {
-      sessionIds: ["session-1"],
-    });
-
-    expect(events.length).toBe(2);
-    expect(events.every((e) => e.session_id === "session-1")).toBe(true);
-  });
-
-  test("applies limit", async () => {
-    const events = await loadCompactionEvents(TEST_SESSION_DIR, {
-      limit: 2,
-    });
-
-    expect(events.length).toBe(2);
-  });
-
-  test("combines filters", async () => {
-    const events = await loadCompactionEvents(TEST_SESSION_DIR, {
-      compaction_type: "prompt_generated",
-      sessionIds: ["session-1"],
-      limit: 1,
-    });
-
-    expect(events.length).toBe(1);
-    expect(events[0].compaction_type).toBe("prompt_generated");
-    expect(events[0].session_id).toBe("session-1");
-  });
-
-  test("returns empty array for non-existent directory", async () => {
-    const events = await loadCompactionEvents("/non/existent/path");
-
-    expect(events).toEqual([]);
-  });
-
-  test("skips invalid JSONL lines", async () => {
-    // Create session with invalid JSON
-    const invalidPath = path.join(TEST_SESSION_DIR, "session-invalid.jsonl");
-    fs.writeFileSync(
-      invalidPath,
-      'invalid json\n{"session_id": "session-valid", "event_type": "COMPACTION", "compaction_type": "detection_complete", "epic_id": "epic-4", "timestamp": "2025-01-04T10:00:00.000Z", "payload": {}}\n',
-      "utf-8",
-    );
-
-    const events = await loadCompactionEvents(TEST_SESSION_DIR);
-
-    // Should skip invalid line but include valid one
-    expect(events.some((e) => e.session_id === "session-valid")).toBe(true);
-
-    // Clean up
-    fs.unlinkSync(invalidPath);
-  });
-});
-
-describe("loadCompactionSessions", () => {
-  test("groups events by session_id", async () => {
-    const sessions = await loadCompactionSessions(TEST_SESSION_DIR);
-
-    expect(sessions.length).toBe(2); // session-1 and session-2 (session-3 has no COMPACTION events)
-    expect(sessions[0].session_id).toBeDefined();
-    expect(sessions[0].events.length).toBeGreaterThan(0);
-  });
-
-  test("includes session metadata", async () => {
-    const sessions = await loadCompactionSessions(TEST_SESSION_DIR);
-
-    const session1 = sessions.find((s) => s.session_id === "session-1");
-    expect(session1).toBeDefined();
-    if (session1) {
-      expect(session1.epic_id).toBe("epic-1");
-      expect(session1.start_time).toBeDefined();
-      expect(session1.end_time).toBeDefined();
-    }
-  });
-
-  test("filters by compaction_type", async () => {
-    const sessions = await loadCompactionSessions(TEST_SESSION_DIR, {
-      compaction_type: "detection_complete",
-    });
-
-    expect(sessions.length).toBe(1);
-    expect(sessions[0].session_id).toBe("session-1");
-  });
-
-  test("filters by session_ids", async () => {
-    const sessions = await loadCompactionSessions(TEST_SESSION_DIR, {
-      sessionIds: ["session-2"],
-    });
-
-    expect(sessions.length).toBe(1);
-    expect(sessions[0].session_id).toBe("session-2");
-  });
-
-  test("applies limit", async () => {
-    const sessions = await loadCompactionSessions(TEST_SESSION_DIR, {
-      limit: 1,
-    });
-
-    expect(sessions.length).toBe(1);
-  });
-
-  test("returns empty array for non-existent directory", async () => {
-    const sessions = await loadCompactionSessions("/non/existent/path");
-
-    expect(sessions).toEqual([]);
-  });
-
-  test("excludes sessions with no COMPACTION events", async () => {
-    const sessions = await loadCompactionSessions(TEST_SESSION_DIR);
-
-    expect(sessions.every((s) => s.session_id !== "session-3")).toBe(true);
-  });
-});

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