opencode-swarm-plugin 0.42.9 → 0.44.0

package/src/replay-tools.ts

@@ -0,0 +1,240 @@
+/**
+ * Replay Tools - Event replay with timing simulation
+ *
+ * TDD GREEN: Minimal implementation to pass tests
+ */
+
+import { readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type ReplaySpeed = "1x" | "2x" | "instant";
+
+export interface ReplayEvent {
+	session_id: string;
+	epic_id: string;
+	timestamp: string;
+	event_type: "DECISION" | "VIOLATION" | "OUTCOME" | "COMPACTION";
+	decision_type?: string;
+	violation_type?: string;
+	outcome_type?: string;
+	payload: Record<string, unknown>;
+	delta_ms: number;
+}
+
+export interface ReplayFilter {
+	type?: Array<"DECISION" | "VIOLATION" | "OUTCOME" | "COMPACTION">;
+	agent?: string;
+	since?: Date;
+	until?: Date;
+}
+
+// ============================================================================
+// fetchEpicEvents - Read JSONL and calculate deltas
+// ============================================================================
+
+export async function fetchEpicEvents(
+	epicId: string,
+	sessionFile: string,
+): Promise<ReplayEvent[]> {
+	// Handle non-existent files
+	if (!existsSync(sessionFile)) {
+		return [];
+	}
+
+	try {
+		const content = readFileSync(sessionFile, "utf-8");
+		const lines = content.trim().split("\n").filter(Boolean);
+
+		if (lines.length === 0) {
+			return [];
+		}
+
+		// Parse JSONL
+		const events = lines.map((line) => JSON.parse(line));
+
+		// Sort by timestamp (chronological order)
+		events.sort(
+			(a, b) =>
+				new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime(),
+		);
+
+		// Calculate delta_ms between events
+		const replayEvents: ReplayEvent[] = [];
+		let prevTime = 0;
+
+		for (const event of events) {
+			const currTime = new Date(event.timestamp).getTime();
+			const delta_ms = prevTime === 0 ? 0 : currTime - prevTime;
+
+			replayEvents.push({
+				...event,
+				delta_ms,
+			});
+
+			prevTime = currTime;
+		}
+
+		return replayEvents;
+	} catch (error) {
+		// Handle errors (e.g., invalid JSON)
+		return [];
+	}
+}
+
+// ============================================================================
+// filterEvents - Filter by type/agent/time (AND logic)
+// ============================================================================
+
+export function filterEvents(
+	events: ReplayEvent[],
+	filter: ReplayFilter,
+): ReplayEvent[] {
+	return events.filter((event) => {
+		// Filter by event type
+		if (filter.type && !filter.type.includes(event.event_type)) {
+			return false;
+		}
+
+		// Filter by agent name (from payload)
+		if (filter.agent) {
+			const payload = event.payload as any;
+			if (payload.agent_name !== filter.agent) {
+				return false;
+			}
+		}
+
+		// Filter by time range (since)
+		if (filter.since) {
+			const eventTime = new Date(event.timestamp);
+			if (eventTime < filter.since) {
+				return false;
+			}
+		}
+
+		// Filter by time range (until)
+		if (filter.until) {
+			const eventTime = new Date(event.timestamp);
+			if (eventTime > filter.until) {
+				return false;
+			}
+		}
+
+		return true;
+	});
+}
+
+// ============================================================================
+// replayWithTiming - Async generator with speed control
+// ============================================================================
+
+export async function* replayWithTiming(
+	events: ReplayEvent[],
+	speed: ReplaySpeed,
+): AsyncGenerator<ReplayEvent> {
+	if (events.length === 0) {
+		return;
+	}
+
+	const startTime = Date.now();
+	let cumulativeDelay = 0;
+
+	for (const event of events) {
+		// Calculate target time for this event
+		cumulativeDelay += event.delta_ms;
+
+		let targetDelay = cumulativeDelay;
+		if (speed === "2x") {
+			targetDelay = targetDelay / 2;
+		} else if (speed === "instant") {
+			targetDelay = 0;
+		}
+
+		// Calculate actual delay needed (accounting for time already elapsed)
+		const elapsed = Date.now() - startTime;
+		const delay = targetDelay - elapsed;
+
+		// Wait for the delay if needed (with small buffer for overhead)
+		if (delay > 3) {
+			// Subtract 3ms buffer to account for async overhead
+			const adjustedDelay = delay - 3;
+
+			// Use Bun.sleep for more precise timing in Bun runtime
+			if (typeof Bun !== "undefined" && typeof Bun.sleep === "function") {
+				await Bun.sleep(adjustedDelay);
+			} else {
+				await new Promise((resolve) => setTimeout(resolve, adjustedDelay));
+			}
+		}
+
+		// Yield the event
+		yield event;
+	}
+}
+
+// ============================================================================
+// formatReplayEvent - ANSI colors + box-drawing + relationships
+// ============================================================================
+
+export function formatReplayEvent(event: ReplayEvent): string {
+	// ANSI color codes
+	const colors = {
+		DECISION: "\x1b[34m", // Blue
+		VIOLATION: "\x1b[31m", // Red
+		OUTCOME: "\x1b[32m", // Green
+		COMPACTION: "\x1b[33m", // Yellow
+		reset: "\x1b[0m",
+		gray: "\x1b[90m",
+	};
+
+	const color = colors[event.event_type] || colors.reset;
+
+	// Format timestamp (remove 'Z' suffix and put it BEFORE color codes for regex match)
+	const timestamp = new Date(event.timestamp)
+		.toISOString()
+		.split("T")[1]
+		.replace("Z", "");
+	const timePrefix = `[${timestamp}]`;
+
+	// Extract relevant payload fields
+	const payload = event.payload as any;
+	const beadId = payload.bead_id || "";
+	const agentName = payload.agent_name || "";
+	const strategyUsed = payload.strategy_used || "";
+	const subtaskCount = payload.subtask_count;
+
+	// Build formatted output with box-drawing characters
+	// Put timestamp BEFORE any color codes so regex matches
+	let output = `${timePrefix} `;
+	output += `${color}┌─ ${event.event_type}${colors.reset}\n`;
+
+	// Epic relationship
+	output += `${colors.gray}│${colors.reset} epic: ${event.epic_id}\n`;
+
+	// Bead relationship (if present)
+	if (beadId) {
+		output += `${colors.gray}│${colors.reset} bead: ${beadId}\n`;
+	}
+
+	// Agent (if present)
+	if (agentName) {
+		output += `${colors.gray}│${colors.reset} agent: ${agentName}\n`;
+	}
+
+	// Strategy (if present)
+	if (strategyUsed) {
+		output += `${colors.gray}│${colors.reset} strategy: ${strategyUsed}\n`;
+	}
+
+	// Subtask count (if present)
+	if (subtaskCount !== undefined) {
+		output += `${colors.gray}│${colors.reset} subtasks: ${subtaskCount}\n`;
+	}
+
+	output += `${colors.gray}└─${colors.reset}`;
+
+	return output;
+}

package/src/sessions/agent-discovery.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Agent Discovery Tests
+ * 
+ * Maps file paths to agent types using pattern matching.
+ * Follows TDD pattern from ADR-010 Section 4.5.
+ */
+
+import { describe, test, expect, afterEach } from "bun:test";
+import {
+  detectAgentType,
+  loadAgentPatterns,
+  resetAgentPatterns,
+} from "./agent-discovery";
+
+describe("detectAgentType", () => {
+  test("detects OpenCode Swarm sessions", () => {
+    expect(
+      detectAgentType(
+        "/home/user/.config/swarm-tools/sessions/ses_123.jsonl"
+      )
+    ).toBe("opencode-swarm");
+  });
+
+  test("detects Cursor sessions", () => {
+    expect(
+      detectAgentType(
+        "/Users/joel/Library/Application Support/Cursor/User/History/abc/9ScS.jsonl"
+      )
+    ).toBe("cursor");
+  });
+
+  test("detects OpenCode sessions", () => {
+    expect(detectAgentType("/Users/joel/.opencode/session.jsonl")).toBe(
+      "opencode"
+    );
+  });
+
+  test("detects Claude sessions", () => {
+    expect(
+      detectAgentType("/home/user/.local/share/Claude/ses_456.jsonl")
+    ).toBe("claude");
+  });
+
+  test("detects Aider sessions", () => {
+    expect(detectAgentType("/home/user/.aider/session.jsonl")).toBe("aider");
+  });
+
+  test("returns null for unknown paths", () => {
+    expect(detectAgentType("/tmp/random.jsonl")).toBeNull();
+  });
+
+  test("handles Windows-style paths", () => {
+    expect(
+      detectAgentType("C:\\Users\\joel\\.config\\swarm-tools\\sessions\\ses.jsonl")
+    ).toBe("opencode-swarm");
+  });
+
+  test("handles nested paths", () => {
+    expect(
+      detectAgentType(
+        "/Users/joel/.opencode/deeply/nested/folder/session.jsonl"
+      )
+    ).toBe("opencode");
+  });
+});
+
+describe("loadAgentPatterns", () => {
+  afterEach(() => {
+    // Reset to defaults after each test
+    resetAgentPatterns();
+  });
+
+  test("loads custom agent patterns", () => {
+    const count = loadAgentPatterns([
+      { pattern: "\\.codex[/\\\\]", agentType: "opencode-swarm" },
+    ]);
+
+    expect(count).toBe(1);
+    expect(detectAgentType("/home/user/.codex/session.jsonl")).toBe(
+      "opencode-swarm"
+    );
+  });
+
+  test("replaces default patterns with custom ones", () => {
+    loadAgentPatterns([
+      { pattern: "\\.custom[/\\\\]", agentType: "cursor" },
+    ]);
+
+    // Custom pattern works
+    expect(detectAgentType("/path/.custom/file.jsonl")).toBe("cursor");
+
+    // Default patterns no longer work
+    expect(
+      detectAgentType("/home/user/.config/swarm-tools/sessions/ses.jsonl")
+    ).toBeNull();
+  });
+
+  test("supports multiple custom patterns", () => {
+    loadAgentPatterns([
+      { pattern: "\\.agent1[/\\\\]", agentType: "opencode-swarm" },
+      { pattern: "\\.agent2[/\\\\]", agentType: "cursor" },
+      { pattern: "\\.agent3[/\\\\]", agentType: "claude" },
+    ]);
+
+    expect(detectAgentType("/path/.agent1/file.jsonl")).toBe(
+      "opencode-swarm"
+    );
+    expect(detectAgentType("/path/.agent2/file.jsonl")).toBe("cursor");
+    expect(detectAgentType("/path/.agent3/file.jsonl")).toBe("claude");
+  });
+});
+
+describe("resetAgentPatterns", () => {
+  test("restores default patterns after custom load", () => {
+    // Load custom patterns
+    loadAgentPatterns([
+      { pattern: "\\.custom[/\\\\]", agentType: "opencode-swarm" },
+    ]);
+
+    // Custom works, defaults don't
+    expect(detectAgentType("/path/.custom/file.jsonl")).toBe(
+      "opencode-swarm"
+    );
+    expect(
+      detectAgentType("/home/user/.config/swarm-tools/sessions/ses.jsonl")
+    ).toBeNull();
+
+    // Reset
+    resetAgentPatterns();
+
+    // Defaults work again
+    expect(
+      detectAgentType("/home/user/.config/swarm-tools/sessions/ses.jsonl")
+    ).toBe("opencode-swarm");
+    expect(detectAgentType("/path/.custom/file.jsonl")).toBeNull();
+  });
+});

package/src/sessions/agent-discovery.ts

@@ -0,0 +1,112 @@
+/**
+ * Agent Discovery Module
+ * 
+ * Maps file paths to agent types using pattern matching.
+ * Supports cross-platform paths (Unix and Windows).
+ * 
+ * @module sessions/agent-discovery
+ */
+
+/**
+ * Agent type identifier
+ */
+export type AgentType =
+  | "opencode-swarm"
+  | "cursor"
+  | "opencode"
+  | "claude"
+  | "aider";
+
+/**
+ * Path pattern configuration for agent type detection
+ */
+interface AgentPathPattern {
+  /** RegExp pattern to match against file path */
+  pattern: RegExp;
+  /** Agent type to return when pattern matches */
+  agentType: AgentType;
+}
+
+/**
+ * Default path patterns for agent type detection
+ * Order matters - first match wins
+ * 
+ * Can be overridden via loadAgentPatterns()
+ */
+let AGENT_PATH_PATTERNS: AgentPathPattern[] = [
+  { pattern: /\.config[\/\\]swarm-tools[\/\\]sessions[\/\\]/, agentType: "opencode-swarm" },
+  { pattern: /Cursor[\/\\]User[\/\\]History[\/\\]/, agentType: "cursor" },
+  { pattern: /\.opencode[\/\\]/, agentType: "opencode" },
+  { pattern: /\.local[\/\\]share[\/\\]Claude[\/\\]/, agentType: "claude" },
+  { pattern: /\.aider/, agentType: "aider" },
+];
+
+/**
+ * Configuration for custom agent patterns
+ */
+interface AgentPatternConfig {
+  /** Pattern string (will be converted to RegExp) */
+  pattern: string;
+  /** Agent type identifier */
+  agentType: AgentType;
+}
+
+/**
+ * Load custom agent patterns from config
+ * 
+ * @param patterns - Array of custom pattern configurations
+ * @returns Number of patterns loaded
+ * 
+ * @example
+ * ```typescript
+ * loadAgentPatterns([
+ *   { pattern: "\\.codex[/\\\\]", agentType: "codex" },
+ *   { pattern: "\\.gemini[/\\\\]", agentType: "gemini" }
+ * ]);
+ * ```
+ */
+export function loadAgentPatterns(patterns: AgentPatternConfig[]): number {
+  AGENT_PATH_PATTERNS = patterns.map(({ pattern, agentType }) => ({
+    pattern: new RegExp(pattern),
+    agentType,
+  }));
+  return AGENT_PATH_PATTERNS.length;
+}
+
+/**
+ * Reset agent patterns to defaults
+ * Useful for testing
+ */
+export function resetAgentPatterns(): void {
+  AGENT_PATH_PATTERNS = [
+    { pattern: /\.config[\/\\]swarm-tools[\/\\]sessions[\/\\]/, agentType: "opencode-swarm" },
+    { pattern: /Cursor[\/\\]User[\/\\]History[\/\\]/, agentType: "cursor" },
+    { pattern: /\.opencode[\/\\]/, agentType: "opencode" },
+    { pattern: /\.local[\/\\]share[\/\\]Claude[\/\\]/, agentType: "claude" },
+    { pattern: /\.aider/, agentType: "aider" },
+  ];
+}
+
+/**
+ * Detect agent type from file path
+ * 
+ * @param filePath - Absolute or relative file path (Unix or Windows)
+ * @returns Agent type identifier, or null if unknown
+ * 
+ * @example
+ * ```typescript
+ * detectAgentType("/home/user/.config/swarm-tools/sessions/ses_123.jsonl")
+ * // => "opencode-swarm"
+ * 
+ * detectAgentType("/tmp/random.jsonl")
+ * // => null
+ * ```
+ */
+export function detectAgentType(filePath: string): AgentType | null {
+  for (const { pattern, agentType } of AGENT_PATH_PATTERNS) {
+    if (pattern.test(filePath)) {
+      return agentType;
+    }
+  }
+  return null;
+}

package/src/sessions/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Session Indexing Module
+ * 
+ * Provides agent session discovery and indexing capabilities.
+ * Part of the CASS Inhousing initiative (ADR-010).
+ * 
+ * @module sessions
+ */
+
+export {
+  detectAgentType,
+  loadAgentPatterns,
+  resetAgentPatterns,
+  type AgentType,
+} from "./agent-discovery";