opencode-swarm-plugin 0.40.0 → 0.42.1

package/src/observability-tools.ts

@@ -582,6 +582,283 @@ const swarm_insights = tool({
 	},
 });
 
+// ============================================================================
+// Stats CLI Helpers (exported for bin/swarm.ts)
+// ============================================================================
+
+export interface SwarmStatsData {
+	overall: {
+		totalSwarms: number;
+		successRate: number;
+		avgDurationMin: number;
+	};
+	byStrategy: Array<{
+		strategy: string;
+		total: number;
+		successRate: number;
+		successes: number;
+	}>;
+	coordinator: {
+		violationRate: number;
+		spawnEfficiency: number;
+		reviewThoroughness: number;
+	};
+	recentDays: number;
+}
+
+/**
+ * Format swarm stats as beautiful CLI output with box drawing
+ */
+export function formatSwarmStats(stats: SwarmStatsData): string {
+	const lines: string[] = [];
+
+	// Header with ASCII art
+	lines.push("┌─────────────────────────────────────────┐");
+	lines.push("│        🐝  SWARM STATISTICS  🐝         │");
+	lines.push("├─────────────────────────────────────────┤");
+
+	// Overall stats
+	const totalStr = stats.overall.totalSwarms.toString().padEnd(4);
+	const rateStr = `${Math.round(stats.overall.successRate)}%`.padStart(3);
+	lines.push(`│ Total Swarms: ${totalStr} Success: ${rateStr}      │`);
+	
+	const durationStr = stats.overall.avgDurationMin.toFixed(1);
+	lines.push(`│ Avg Duration: ${durationStr}min${" ".repeat(23 - durationStr.length)}│`);
+	lines.push("├─────────────────────────────────────────┤");
+
+	// Strategy breakdown
+	lines.push("│ BY STRATEGY                             │");
+	if (stats.byStrategy.length === 0) {
+		lines.push("│ ├─ No data yet                          │");
+	} else {
+		for (const strategy of stats.byStrategy) {
+			const label = strategy.strategy.padEnd(15);
+			const rate = `${Math.round(strategy.successRate)}%`.padStart(4);
+			const counts = `(${strategy.successes}/${strategy.total})`.padEnd(8);
+			lines.push(`│ ├─ ${label} ${rate} ${counts}     │`);
+		}
+	}
+	lines.push("├─────────────────────────────────────────┤");
+
+	// Coordinator health
+	lines.push("│ COORDINATOR HEALTH                      │");
+	const violationStr = `${Math.round(stats.coordinator.violationRate)}%`.padStart(3);
+	const spawnStr = `${Math.round(stats.coordinator.spawnEfficiency)}%`.padStart(4);
+	const reviewStr = `${Math.round(stats.coordinator.reviewThoroughness)}%`.padStart(3);
+	
+	lines.push(`│ Violation Rate:   ${violationStr}${" ".repeat(19 - violationStr.length)}│`);
+	lines.push(`│ Spawn Efficiency: ${spawnStr}${" ".repeat(17 - spawnStr.length)}│`);
+	lines.push(`│ Review Rate:      ${reviewStr}${" ".repeat(19 - reviewStr.length)}│`);
+	lines.push("└─────────────────────────────────────────┘");
+	
+	lines.push("");
+	lines.push(`📊 Stats for last ${stats.recentDays} days`);
+
+	return lines.join("\n");
+}
+
+/**
+ * Parse time period string like "7d", "24h", "30m" to timestamp
+ */
+export function parseTimePeriod(period: string): number {
+	const match = period.match(/^(\d+)([dhm])$/);
+	if (!match) {
+		throw new Error(
+			`Invalid time period format: ${period}. Use "7d", "24h", or "30m"`,
+		);
+	}
+
+	const [, value, unit] = match;
+	const num = Number.parseInt(value, 10);
+	const now = Date.now();
+
+	switch (unit) {
+		case "d":
+			return now - num * 24 * 60 * 60 * 1000;
+		case "h":
+			return now - num * 60 * 60 * 1000;
+		case "m":
+			return now - num * 60 * 1000;
+		default:
+			throw new Error(`Unknown time unit: ${unit}`);
+	}
+}
+
+/**
+ * Aggregate swarm outcomes by strategy
+ */
+export function aggregateByStrategy(
+	outcomes: Array<{ strategy: string | null; success: boolean }>,
+): Array<{ strategy: string; total: number; successRate: number; successes: number }> {
+	const grouped: Record<string, { total: number; successes: number }> = {};
+
+	for (const outcome of outcomes) {
+		const strategy = outcome.strategy || "unknown";
+		if (!grouped[strategy]) {
+			grouped[strategy] = { total: 0, successes: 0 };
+		}
+		grouped[strategy].total++;
+		if (outcome.success) {
+			grouped[strategy].successes++;
+		}
+	}
+
+	return Object.entries(grouped).map(([strategy, stats]) => ({
+		strategy,
+		total: stats.total,
+		successes: stats.successes,
+		successRate: (stats.successes / stats.total) * 100,
+	}));
+}
+
+// ============================================================================
+// History CLI Helpers (exported for bin/swarm.ts)
+// ============================================================================
+
+export interface SwarmHistoryRecord {
+	epic_id: string;
+	epic_title: string;
+	strategy: string;
+	timestamp: string;
+	overall_success: boolean;
+	task_count: number;
+	completed_count: number;
+}
+
+/**
+ * Query swarm history from eval_records table
+ */
+export async function querySwarmHistory(
+	projectPath: string,
+	options?: {
+		limit?: number;
+		status?: "success" | "failed" | "in_progress";
+		strategy?: "file-based" | "feature-based" | "risk-based";
+	},
+): Promise<SwarmHistoryRecord[]> {
+	const swarmMail = await getSwarmMailLibSQL(projectPath);
+	const db = await swarmMail.getDatabase();
+
+	// Build WHERE clause
+	const conditions: string[] = [];
+	const params: (string | number)[] = [];
+
+	if (options?.status) {
+		switch (options.status) {
+			case "success":
+				conditions.push("json_extract(data, '$.overall_success') = 'true'");
+				break;
+			case "failed":
+				conditions.push(
+					"json_extract(data, '$.overall_success') = 'false' AND json_extract(data, '$.completed_count') = json_extract(data, '$.task_count')",
+				);
+				break;
+			case "in_progress":
+				conditions.push(
+					"json_extract(data, '$.completed_count') < json_extract(data, '$.task_count')",
+				);
+				break;
+		}
+	}
+
+	if (options?.strategy) {
+		conditions.push("json_extract(data, '$.strategy') = ?");
+		params.push(options.strategy);
+	}
+
+	const whereClause = conditions.length > 0 ? `AND ${conditions.join(" AND ")}` : "";
+	const limit = options?.limit || 10;
+
+	const query = `
+		SELECT 
+			json_extract(data, '$.epic_id') as epic_id,
+			json_extract(data, '$.task') as epic_title,
+			json_extract(data, '$.strategy') as strategy,
+			timestamp,
+			json_extract(data, '$.overall_success') as overall_success,
+			CAST(json_extract(data, '$.task_count') AS INTEGER) as task_count,
+			CAST(json_extract(data, '$.completed_count') AS INTEGER) as completed_count
+		FROM events
+		WHERE type = 'eval_finalized'
+		${whereClause}
+		ORDER BY timestamp DESC
+		LIMIT ?
+	`;
+
+	params.push(limit);
+
+	const result = await db.query(query, params);
+	const rows = result.rows as unknown[];
+
+	return rows.map((row) => {
+		const r = row as Record<string, unknown>;
+		return {
+			epic_id: String(r.epic_id || ""),
+			epic_title: String(r.epic_title || "Unknown"),
+			strategy: String(r.strategy || "unknown"),
+			timestamp: String(r.timestamp || new Date().toISOString()),
+			overall_success: String(r.overall_success) === "true",
+			task_count: Number(r.task_count) || 0,
+			completed_count: Number(r.completed_count) || 0,
+		};
+	});
+}
+
+/**
+ * Format relative time (e.g., "2h ago", "1d ago")
+ */
+export function formatRelativeTime(timestamp: string): string {
+	const now = Date.now();
+	const then = new Date(timestamp).getTime();
+	const diffMs = now - then;
+
+	const minutes = Math.floor(diffMs / 60000);
+	const hours = Math.floor(diffMs / 3600000);
+	const days = Math.floor(diffMs / 86400000);
+
+	if (minutes < 60) return `${minutes}m ago`;
+	if (hours < 24) return `${hours}h ago`;
+	return `${days}d ago`;
+}
+
+/**
+ * Format swarm history as beautiful CLI table
+ */
+export function formatSwarmHistory(records: SwarmHistoryRecord[]): string {
+	if (records.length === 0) {
+		return "No swarm history found";
+	}
+
+	const rows = records.map((r) => ({
+		time: formatRelativeTime(r.timestamp),
+		status: r.overall_success ? "✅" : "❌",
+		title:
+			r.epic_title.length > 30 ? `${r.epic_title.slice(0, 27)}...` : r.epic_title,
+		strategy: r.strategy,
+		tasks: `${r.completed_count}/${r.task_count} tasks`,
+	}));
+
+	// Box drawing characters
+	const lines: string[] = [];
+	lines.push("┌─────────────────────────────────────────────────────────────┐");
+	lines.push("│                    SWARM HISTORY                            │");
+	lines.push("├─────────────────────────────────────────────────────────────┤");
+
+	for (const row of rows) {
+		const statusCol = `${row.time.padEnd(8)} ${row.status}`;
+		const titleCol = row.title.padEnd(32);
+		const strategyCol = row.strategy.padEnd(13);
+		const tasksCol = row.tasks;
+
+		const line = `│ ${statusCol} ${titleCol} ${strategyCol} ${tasksCol.padEnd(3)} │`;
+		lines.push(line);
+	}
+
+	lines.push("└─────────────────────────────────────────────────────────────┘");
+
+	return lines.join("\n");
+}
+
 // ============================================================================
 // Exports
 // ============================================================================

package/src/swarm-orchestrate.test.ts

@@ -272,6 +272,168 @@ describe("captureSubtaskOutcome integration", () => {
   });
 });
 
+// ============================================================================
+// Event Emission Tests (subtask_outcome events to libSQL)
+// ============================================================================
+
+describe("subtask_outcome event emission", () => {
+  const mockContext = {
+    sessionID: `test-event-emission-${Date.now()}`,
+    messageID: `test-message-${Date.now()}`,
+    agent: "test-agent",
+    abort: new AbortController().signal,
+  };
+
+  let testProjectPath: string;
+
+  beforeEach(async () => {
+    testProjectPath = `/tmp/test-event-emission-${Date.now()}`;
+    fs.mkdirSync(testProjectPath, { recursive: true });
+    
+    // Create .hive directory and issues.jsonl
+    const hiveDir = `${testProjectPath}/.hive`;
+    fs.mkdirSync(hiveDir, { recursive: true });
+    fs.writeFileSync(`${hiveDir}/issues.jsonl`, "", "utf-8");
+    
+    // Set hive working directory to testProjectPath
+    const { setHiveWorkingDirectory } = await import("./hive");
+    setHiveWorkingDirectory(testProjectPath);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testProjectPath)) {
+      fs.rmSync(testProjectPath, { recursive: true, force: true });
+    }
+  });
+
+  test("swarm_complete emits subtask_outcome event to libSQL database", async () => {
+    // Import dependencies
+    const { hive_create_epic } = await import("./hive");
+    const { readEvents, getSwarmMailLibSQL } = await import("swarm-mail");
+
+    // Create an epic with a subtask
+    const epicResult = await hive_create_epic.execute({
+      epic_title: "Add feature X",
+      subtasks: [
+        {
+          title: "Implement X service",
+          priority: 2,
+          files: ["src/x.ts"],
+        },
+      ],
+    }, mockContext);
+    
+    const epicData = JSON.parse(epicResult);
+    const epicId = epicData.epic.id;
+    const beadId = epicData.subtasks[0].id;
+
+    const startTime = Date.now() - 60000; // Started 1 minute ago
+
+    // Call swarm_complete
+    const result = await swarm_complete.execute(
+      {
+        project_key: testProjectPath,
+        agent_name: "TestAgent",
+        bead_id: beadId,
+        summary: "Implemented X service",
+        files_touched: ["src/x.ts"],
+        skip_verification: true,
+        skip_review: true,
+        planned_files: ["src/x.ts"],
+        start_time: startTime,
+        error_count: 0,
+        retry_count: 0,
+      },
+      mockContext,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.success).toBe(true);
+
+    // Query events from libSQL database
+    const events = await readEvents({
+      projectKey: testProjectPath,
+      types: ["subtask_outcome"],
+    }, testProjectPath);
+
+    // Should have exactly 1 subtask_outcome event
+    expect(events.length).toBe(1);
+    
+    const event = events[0] as any;
+    expect(event.type).toBe("subtask_outcome");
+    expect(event.epic_id).toBe(epicId);
+    expect(event.bead_id).toBe(beadId);
+    expect(event.success).toBe(true);
+    expect(event.duration_ms).toBeGreaterThan(0);
+  });
+
+  test("subtask_outcome event updates eval_records.outcomes in libSQL", async () => {
+    // Import dependencies
+    const { hive_create_epic } = await import("./hive");
+    const { getSwarmMailLibSQL } = await import("swarm-mail");
+
+    // Create an epic with a subtask
+    const epicResult = await hive_create_epic.execute({
+      epic_title: "Add feature Y",
+      subtasks: [
+        {
+          title: "Implement Y service",
+          priority: 2,
+          files: ["src/y.ts"],
+        },
+      ],
+    }, mockContext);
+    
+    const epicData = JSON.parse(epicResult);
+    const epicId = epicData.epic.id;
+    const beadId = epicData.subtasks[0].id;
+
+    const startTime = Date.now() - 90000; // Started 1.5 minutes ago
+
+    // Call swarm_complete
+    await swarm_complete.execute(
+      {
+        project_key: testProjectPath,
+        agent_name: "TestAgent",
+        bead_id: beadId,
+        summary: "Implemented Y service",
+        files_touched: ["src/y.ts", "src/y.test.ts"],
+        skip_verification: true,
+        skip_review: true,
+        planned_files: ["src/y.ts"],
+        start_time: startTime,
+        error_count: 0,
+        retry_count: 0,
+      },
+      mockContext,
+    );
+
+    // Query eval_records from libSQL
+    const swarmMail = await getSwarmMailLibSQL(testProjectPath);
+    const db = await swarmMail.getDatabase();
+
+    const result = await db.query<{ outcomes: string | null }>(
+      `SELECT outcomes FROM eval_records WHERE id = ?`,
+      [epicId]
+    );
+
+    expect(result.rows.length).toBe(1);
+    
+    const outcomes = result.rows[0].outcomes;
+    expect(outcomes).not.toBeNull();
+    
+    const parsed = JSON.parse(outcomes || "[]");
+    expect(parsed.length).toBe(1);
+    
+    const outcome = parsed[0];
+    expect(outcome.bead_id).toBe(beadId);
+    expect(outcome.success).toBe(true);
+    expect(outcome.duration_ms).toBeGreaterThan(0);
+    expect(outcome.planned_files).toEqual(["src/y.ts"]);
+    expect(outcome.actual_files).toEqual(["src/y.ts", "src/y.test.ts"]);
+  });
+});
+
 // ============================================================================
 // Eval Capture Integration Tests (swarm_record_outcome)
 // ============================================================================

package/src/swarm-orchestrate.ts

@@ -1510,15 +1510,17 @@ This will be recorded as a negative learning signal.`;
 
       // Emit SubtaskOutcomeEvent for learning system
       try {
-        const epicId = args.bead_id.includes(".")
-          ? args.bead_id.split(".")[0]
-          : args.bead_id;
-
         const durationMs = args.start_time ? Date.now() - args.start_time : 0;
+        
+        // Determine epic ID: use parent_id if available, otherwise fall back to extracting from bead_id
+        // (New hive cell IDs don't follow epicId.subtaskNum pattern - they're independent IDs)
+        const eventEpicId = cell.parent_id || (args.bead_id.includes(".")
+          ? args.bead_id.split(".")[0]
+          : args.bead_id);
 
         const event = createEvent("subtask_outcome", {
           project_key: args.project_key,
-          epic_id: epicId,
+          epic_id: eventEpicId,
           bead_id: args.bead_id,
           planned_files: args.planned_files || [],
           actual_files: args.files_touched || [],

package/src/swarm-prompts.test.ts

@@ -146,8 +146,8 @@ describe("SUBTASK_PROMPT_V2", () => {
 });
 
 describe("formatSubtaskPromptV2", () => {
-  test("substitutes all placeholders correctly", () => {
-    const result = formatSubtaskPromptV2({
+  test("substitutes all placeholders correctly", async () => {
+    const result = await formatSubtaskPromptV2({
       bead_id: "test-project-abc123-bead456",
       epic_id: "test-project-abc123-epic789",
       subtask_title: "Test Subtask",
@@ -165,8 +165,8 @@ describe("formatSubtaskPromptV2", () => {
     expect(result).toContain("/path/to/project");
   });
 
-  test("includes memory query step with MANDATORY emphasis", () => {
-    const result = formatSubtaskPromptV2({
+  test("includes memory query step with MANDATORY emphasis", async () => {
+    const result = await formatSubtaskPromptV2({
       bead_id: "test-project-abc123-def456",
       epic_id: "test-project-abc123-ghi789",
       subtask_title: "Test",
@@ -939,3 +939,167 @@ describe("formatCoordinatorPrompt", () => {
     expect(result).toContain("Phase 1.5:");
   });
 });
+
+describe("getRecentEvalFailures", () => {
+  test("returns empty string when no failures exist", async () => {
+    const { getRecentEvalFailures } = await import("./swarm-prompts");
+    const result = await getRecentEvalFailures();
+    
+    // Should not throw and returns string
+    expect(typeof result).toBe("string");
+    // When no failures, returns empty or a message - either is acceptable
+  });
+  
+  test("returns formatted string when failures exist", async () => {
+    const { getRecentEvalFailures } = await import("./swarm-prompts");
+    
+    // This test depends on actual memory state
+    // Just verify it doesn't throw and returns a string
+    const result = await getRecentEvalFailures();
+    expect(typeof result).toBe("string");
+  });
+  
+  test("includes warning emoji in header when failures present", async () => {
+    const { getRecentEvalFailures } = await import("./swarm-prompts");
+    
+    // If there are failures in the system, the header should have ⚠️
+    const result = await getRecentEvalFailures();
+    
+    // Either empty (no failures) or contains the warning section
+    if (result.length > 0) {
+      expect(result).toMatch(/⚠️|Recent Eval Failures/);
+    }
+  });
+  
+  test("handles memory adapter errors gracefully", async () => {
+    const { getRecentEvalFailures } = await import("./swarm-prompts");
+    
+    // Should not throw even if memory is unavailable
+    await expect(getRecentEvalFailures()).resolves.toBeDefined();
+  });
+});
+
+describe("getPromptInsights", () => {
+  describe("for coordinators (planning prompts)", () => {
+    test("returns formatted insights string", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ role: "coordinator" });
+      
+      expect(typeof result).toBe("string");
+    });
+
+    test.skip("includes strategy success rates when data exists", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ role: "coordinator" });
+      
+      // If there's data, should mention strategies
+      if (result.length > 0) {
+        expect(result).toMatch(/strategy|file-based|feature-based|risk-based/i);
+      }
+    });
+
+    test.skip("includes recent failure patterns", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ role: "coordinator" });
+      
+      // Should query for failures and anti-patterns
+      if (result.length > 0) {
+        expect(result).toMatch(/avoid|failure|anti-pattern|success rate/i);
+      }
+    });
+
+    test.skip("returns empty string when no data available", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      
+      // With project_key filter that doesn't exist, should return empty
+      const result = await getPromptInsights({ 
+        role: "coordinator",
+        project_key: "non-existent-project-xyz123"
+      });
+      
+      expect(typeof result).toBe("string");
+    });
+  });
+
+  describe("for workers (subtask prompts)", () => {
+    test.skip("returns formatted insights string", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ 
+        role: "worker",
+        files: ["src/test.ts"]
+      });
+      
+      expect(typeof result).toBe("string");
+    });
+
+    test.skip("queries semantic-memory for file-specific learnings", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ 
+        role: "worker",
+        files: ["src/auth.ts", "src/api/login.ts"]
+      });
+      
+      // Should query semantic memory with file/domain keywords
+      // Result format doesn't matter, just verify it doesn't throw
+      expect(typeof result).toBe("string");
+    });
+
+    test.skip("includes common pitfalls for domain area", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ 
+        role: "worker",
+        domain: "authentication"
+      });
+      
+      if (result.length > 0) {
+        expect(result).toMatch(/pitfall|gotcha|warning|common|issue/i);
+      }
+    });
+  });
+
+  describe("handles errors gracefully", () => {
+    test.skip("returns empty string when database unavailable", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      
+      // Should not throw even if swarm-mail DB is unavailable
+      await expect(getPromptInsights({ role: "coordinator" })).resolves.toBeDefined();
+    });
+
+    test.skip("returns empty string when semantic-memory unavailable", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      
+      // Should not throw even if memory is unavailable
+      await expect(getPromptInsights({ role: "worker", files: [] })).resolves.toBeDefined();
+    });
+  });
+
+  describe("formatting", () => {
+    test.skip("formats strategy stats as readable table", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ role: "coordinator" });
+      
+      if (result.includes("Strategy")) {
+        // Should use markdown table or similar readable format
+        expect(result).toMatch(/\|.*\||\n-+\n|Strategy.*Success/i);
+      }
+    });
+
+    test.skip("limits output to prevent context bloat", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ role: "coordinator" });
+      
+      // Should cap at reasonable length (say, 1500 chars max)
+      expect(result.length).toBeLessThan(2000);
+    });
+
+    test.skip("includes visual emphasis (emoji or markdown)", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ role: "coordinator" });
+      
+      if (result.length > 0) {
+        // Should have at least some formatting
+        expect(result).toMatch(/##|📊|✅|❌|⚠️|\*\*/);
+      }
+    });
+  });
+});