opencode-swarm-plugin 0.35.0 → 0.36.1

package/src/eval-capture.test.ts

@@ -0,0 +1,390 @@
+/**
+ * Tests for eval-capture coordinator event schemas and session capture
+ */
+import { type Mock, 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,
+  CoordinatorEventSchema,
+  type CoordinatorSession,
+  CoordinatorSessionSchema,
+  captureCoordinatorEvent,
+  saveSession,
+} from "./eval-capture.js";
+
+describe("CoordinatorEvent schemas", () => {
+  describe("DECISION events", () => {
+    test("validates strategy_selected event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "strategy_selected",
+        payload: {
+          strategy: "file-based",
+          reasoning: "Files are well isolated",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates worker_spawned event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "worker_spawned",
+        payload: {
+          worker_id: "GreenStorm",
+          subtask_id: "bd-123.1",
+          files: ["src/test.ts"],
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates review_completed event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "review_completed",
+        payload: {
+          subtask_id: "bd-123.1",
+          approved: true,
+          issues_found: 0,
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates decomposition_complete event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "decomposition_complete",
+        payload: {
+          subtask_count: 3,
+          strategy: "feature-based",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+  });
+
+  describe("VIOLATION events", () => {
+    test("validates coordinator_edited_file event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "VIOLATION",
+        violation_type: "coordinator_edited_file",
+        payload: {
+          file: "src/bad.ts",
+          operation: "edit",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates coordinator_ran_tests event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "VIOLATION",
+        violation_type: "coordinator_ran_tests",
+        payload: {
+          command: "bun test",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates coordinator_reserved_files event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "VIOLATION",
+        violation_type: "coordinator_reserved_files",
+        payload: {
+          files: ["src/auth.ts"],
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates no_worker_spawned event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "VIOLATION",
+        violation_type: "no_worker_spawned",
+        payload: {
+          subtask_id: "bd-123.1",
+          reason: "Did work directly",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+  });
+
+  describe("OUTCOME events", () => {
+    test("validates subtask_success event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "OUTCOME",
+        outcome_type: "subtask_success",
+        payload: {
+          subtask_id: "bd-123.1",
+          duration_ms: 45000,
+          files_touched: ["src/auth.ts"],
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates subtask_retry event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "OUTCOME",
+        outcome_type: "subtask_retry",
+        payload: {
+          subtask_id: "bd-123.1",
+          retry_count: 2,
+          reason: "Review rejected",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates subtask_failed event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "OUTCOME",
+        outcome_type: "subtask_failed",
+        payload: {
+          subtask_id: "bd-123.1",
+          error: "Type error in auth.ts",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates epic_complete event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "OUTCOME",
+        outcome_type: "epic_complete",
+        payload: {
+          success: true,
+          total_duration_ms: 180000,
+          subtasks_completed: 3,
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+  });
+});
+
+describe("CoordinatorSession schema", () => {
+  test("validates complete session", () => {
+    const session: CoordinatorSession = {
+      session_id: "test-session",
+      epic_id: "bd-123",
+      start_time: new Date().toISOString(),
+      end_time: new Date().toISOString(),
+      events: [
+        {
+          session_id: "test-session",
+          epic_id: "bd-123",
+          timestamp: new Date().toISOString(),
+          event_type: "DECISION",
+          decision_type: "strategy_selected",
+          payload: { strategy: "file-based" },
+        },
+      ],
+    };
+
+    expect(() => CoordinatorSessionSchema.parse(session)).not.toThrow();
+  });
+
+  test("validates session without end_time", () => {
+    const session: Partial<CoordinatorSession> = {
+      session_id: "test-session",
+      epic_id: "bd-123",
+      start_time: new Date().toISOString(),
+      events: [],
+    };
+
+    expect(() => CoordinatorSessionSchema.parse(session)).not.toThrow();
+  });
+});
+
+describe("captureCoordinatorEvent", () => {
+  let sessionDir: string;
+  let sessionId: string;
+
+  beforeEach(() => {
+    sessionDir = path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+    sessionId = `test-${Date.now()}`;
+  });
+
+  afterEach(() => {
+    // Clean up test session file
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    if (fs.existsSync(sessionPath)) {
+      fs.unlinkSync(sessionPath);
+    }
+  });
+
+  test("creates session directory if not exists", () => {
+    const event: CoordinatorEvent = {
+      session_id: sessionId,
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "DECISION",
+      decision_type: "strategy_selected",
+      payload: { strategy: "file-based" },
+    };
+
+    captureCoordinatorEvent(event);
+
+    expect(fs.existsSync(sessionDir)).toBe(true);
+  });
+
+  test("appends event to session file", () => {
+    const event: CoordinatorEvent = {
+      session_id: sessionId,
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "DECISION",
+      decision_type: "strategy_selected",
+      payload: { strategy: "file-based" },
+    };
+
+    captureCoordinatorEvent(event);
+
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    expect(fs.existsSync(sessionPath)).toBe(true);
+
+    const content = fs.readFileSync(sessionPath, "utf-8");
+    const lines = content.trim().split("\n");
+    expect(lines).toHaveLength(1);
+
+    const parsed = JSON.parse(lines[0]);
+    expect(parsed.session_id).toBe(sessionId);
+    expect(parsed.event_type).toBe("DECISION");
+  });
+
+  test("appends multiple events to same session", () => {
+    const event1: CoordinatorEvent = {
+      session_id: sessionId,
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "DECISION",
+      decision_type: "strategy_selected",
+      payload: { strategy: "file-based" },
+    };
+
+    const event2: CoordinatorEvent = {
+      session_id: sessionId,
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "VIOLATION",
+      violation_type: "coordinator_edited_file",
+      payload: { file: "src/bad.ts" },
+    };
+
+    captureCoordinatorEvent(event1);
+    captureCoordinatorEvent(event2);
+
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    const content = fs.readFileSync(sessionPath, "utf-8");
+    const lines = content.trim().split("\n");
+    expect(lines).toHaveLength(2);
+  });
+});
+
+describe("saveSession", () => {
+  let sessionDir: string;
+  let sessionId: string;
+
+  beforeEach(() => {
+    sessionDir = path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+    sessionId = `test-${Date.now()}`;
+  });
+
+  afterEach(() => {
+    // Clean up test session file
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    if (fs.existsSync(sessionPath)) {
+      fs.unlinkSync(sessionPath);
+    }
+  });
+
+  test("wraps events in session structure", () => {
+    // Capture some events
+    const event1: CoordinatorEvent = {
+      session_id: sessionId,
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "DECISION",
+      decision_type: "strategy_selected",
+      payload: { strategy: "file-based" },
+    };
+
+    captureCoordinatorEvent(event1);
+
+    // Save session
+    const session = saveSession({
+      session_id: sessionId,
+      epic_id: "bd-123",
+    });
+
+    expect(session).toBeDefined();
+    expect(session.session_id).toBe(sessionId);
+    expect(session.events).toHaveLength(1);
+    expect(session.start_time).toBeDefined();
+    expect(session.end_time).toBeDefined();
+  });
+
+  test("returns null if session file does not exist", () => {
+    const session = saveSession({
+      session_id: "nonexistent",
+      epic_id: "bd-999",
+    });
+
+    expect(session).toBeNull();
+  });
+});

package/src/eval-capture.ts

@@ -9,12 +9,15 @@
  * 2. swarm_complete captures: outcome signals per subtask
  * 3. swarm_record_outcome captures: learning signals
  * 4. Human feedback (optional): accept/reject/modify
+ * 5. Coordinator events: decisions, violations, outcomes
+ * 6. Session capture: full coordinator session to ~/.config/swarm-tools/sessions/
  *
  * @module eval-capture
  */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs";
-import * as path from "path";
 
 // ============================================================================
 // Schemas
@@ -63,8 +66,8 @@ export const EvalRecordSchema = z.object({
   context: z.string().optional(),
   /** Strategy used for decomposition */
   strategy: z.enum(["file-based", "feature-based", "risk-based", "auto"]),
-  /** Max subtasks requested */
-  max_subtasks: z.number().int().min(1).max(10),
+  /** Number of subtasks generated */
+  subtask_count: z.number().int().min(1),
 
   // OUTPUT (the decomposition)
   /** Epic title */
@@ -119,6 +122,67 @@ export type PartialEvalRecord = Partial<EvalRecord> & {
   task: string;
 };
 
+/**
+ * Coordinator Event - captures coordinator decisions, violations, and outcomes
+ */
+export const CoordinatorEventSchema = z.discriminatedUnion("event_type", [
+  // DECISION events
+  z.object({
+    session_id: z.string(),
+    epic_id: z.string(),
+    timestamp: z.string(),
+    event_type: z.literal("DECISION"),
+    decision_type: z.enum([
+      "strategy_selected",
+      "worker_spawned",
+      "review_completed",
+      "decomposition_complete",
+    ]),
+    payload: z.any(),
+  }),
+  // VIOLATION events
+  z.object({
+    session_id: z.string(),
+    epic_id: z.string(),
+    timestamp: z.string(),
+    event_type: z.literal("VIOLATION"),
+    violation_type: z.enum([
+      "coordinator_edited_file",
+      "coordinator_ran_tests",
+      "coordinator_reserved_files",
+      "no_worker_spawned",
+    ]),
+    payload: z.any(),
+  }),
+  // OUTCOME events
+  z.object({
+    session_id: z.string(),
+    epic_id: z.string(),
+    timestamp: z.string(),
+    event_type: z.literal("OUTCOME"),
+    outcome_type: z.enum([
+      "subtask_success",
+      "subtask_retry",
+      "subtask_failed",
+      "epic_complete",
+    ]),
+    payload: z.any(),
+  }),
+]);
+export type CoordinatorEvent = z.infer<typeof CoordinatorEventSchema>;
+
+/**
+ * Coordinator Session - wraps a full coordinator session
+ */
+export const CoordinatorSessionSchema = z.object({
+  session_id: z.string(),
+  epic_id: z.string(),
+  start_time: z.string(),
+  end_time: z.string().optional(),
+  events: z.array(CoordinatorEventSchema),
+});
+export type CoordinatorSession = z.infer<typeof CoordinatorSessionSchema>;
+
 // ============================================================================
 // Storage
 // ============================================================================
@@ -155,7 +219,7 @@ export function appendEvalRecord(
 ): void {
   ensureEvalDataDir(projectPath);
   const evalPath = getEvalDataPath(projectPath);
-  const line = JSON.stringify(record) + "\n";
+  const line = `${JSON.stringify(record)}\n`;
   fs.appendFileSync(evalPath, line, "utf-8");
 }
 
@@ -211,7 +275,7 @@ export function updateEvalRecord(
 
   // Rewrite the file
   const evalPath = getEvalDataPath(projectPath);
-  const content = records.map((r) => JSON.stringify(r)).join("\n") + "\n";
+  const content = `${records.map((r) => JSON.stringify(r)).join("\n")}\n`;
   fs.writeFileSync(evalPath, content, "utf-8");
 
   return true;
@@ -238,7 +302,6 @@ export function captureDecomposition(params: {
   task: string;
   context?: string;
   strategy: "file-based" | "feature-based" | "risk-based" | "auto";
-  maxSubtasks: number;
   epicTitle: string;
   epicDescription?: string;
   subtasks: Array<{
@@ -256,7 +319,7 @@ export function captureDecomposition(params: {
     task: params.task,
     context: params.context,
     strategy: params.strategy,
-    max_subtasks: params.maxSubtasks,
+    subtask_count: params.subtasks.length,
     epic_title: params.epicTitle,
     epic_description: params.epicDescription,
     subtasks: params.subtasks,
@@ -409,7 +472,7 @@ export function exportForEvalite(projectPath: string): Array<{
   input: { task: string; context?: string };
   expected: {
     minSubtasks: number;
-    maxSubtasks: number;
+    subtaskCount: number;
     requiredFiles?: string[];
     overallSuccess?: boolean;
   };
@@ -426,7 +489,7 @@ export function exportForEvalite(projectPath: string): Array<{
       },
       expected: {
         minSubtasks: 2,
-        maxSubtasks: record.max_subtasks,
+        subtaskCount: record.subtask_count,
         requiredFiles: record.subtasks.flatMap((s) => s.files),
         overallSuccess: record.overall_success,
       },
@@ -485,3 +548,98 @@ export function getEvalDataStats(projectPath: string): {
     avgTimeBalance,
   };
 }
+
+// ============================================================================
+// Coordinator Session Capture
+// ============================================================================
+
+/**
+ * Get the session directory path
+ */
+export function getSessionDir(): string {
+  return path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+}
+
+/**
+ * Get the session file path for a session ID
+ */
+export function getSessionPath(sessionId: string): string {
+  return path.join(getSessionDir(), `${sessionId}.jsonl`);
+}
+
+/**
+ * Ensure the session directory exists
+ */
+export function ensureSessionDir(): void {
+  const sessionDir = getSessionDir();
+  if (!fs.existsSync(sessionDir)) {
+    fs.mkdirSync(sessionDir, { recursive: true });
+  }
+}
+
+/**
+ * Capture a coordinator event to the session file
+ *
+ * Appends the event as a JSONL line to ~/.config/swarm-tools/sessions/{session_id}.jsonl
+ */
+export function captureCoordinatorEvent(event: CoordinatorEvent): void {
+  // Validate event
+  CoordinatorEventSchema.parse(event);
+
+  // Ensure directory exists
+  ensureSessionDir();
+
+  // Append to session file
+  const sessionPath = getSessionPath(event.session_id);
+  const line = `${JSON.stringify(event)}\n`;
+  fs.appendFileSync(sessionPath, line, "utf-8");
+}
+
+/**
+ * Read all events from a session file
+ */
+export function readSessionEvents(sessionId: string): CoordinatorEvent[] {
+  const sessionPath = getSessionPath(sessionId);
+  if (!fs.existsSync(sessionPath)) {
+    return [];
+  }
+
+  const content = fs.readFileSync(sessionPath, "utf-8");
+  const lines = content.trim().split("\n").filter(Boolean);
+
+  return lines.map((line) => {
+    const parsed = JSON.parse(line);
+    return CoordinatorEventSchema.parse(parsed);
+  });
+}
+
+/**
+ * Save a session - wraps all events in a CoordinatorSession structure
+ *
+ * Reads all events from the session file and wraps them in a session object.
+ * Returns null if the session file doesn't exist.
+ */
+export function saveSession(params: {
+  session_id: string;
+  epic_id: string;
+}): CoordinatorSession | null {
+  const events = readSessionEvents(params.session_id);
+  if (events.length === 0) {
+    return null;
+  }
+
+  // Get timestamps from events
+  const timestamps = events.map((e) => new Date(e.timestamp).getTime());
+  const startTime = new Date(Math.min(...timestamps)).toISOString();
+  const endTime = new Date(Math.max(...timestamps)).toISOString();
+
+  const session: CoordinatorSession = {
+    session_id: params.session_id,
+    epic_id: params.epic_id,
+    start_time: startTime,
+    end_time: endTime,
+    events,
+  };
+
+  return session;
+}