opencode-swarm-plugin 0.43.0 → 0.44.1

package/src/model-selection.ts

@@ -1,68 +0,0 @@
-/**
- * Model Selection Module
- *
- * Determines which model a worker agent should use based on subtask
- * characteristics like file types and complexity.
- *
- * Priority:
- * 1. Explicit model field in subtask
- * 2. File-type inference (docs/tests → lite model)
- * 3. Default to primary model
- */
-
-import type { DecomposedSubtask } from "./schemas/task";
-
-/**
- * Configuration interface for swarm models
- */
-export interface SwarmConfig {
-  primaryModel: string;
-  liteModel?: string;
-}
-
-/**
- * Select the appropriate model for a worker agent based on subtask characteristics
- *
- * Priority order:
- * 1. Explicit `model` field in subtask (if present)
- * 2. File-type inference:
- *    - All .md/.mdx files → liteModel
- *    - All .test./.spec. files → liteModel
- * 3. Mixed files or implementation → primaryModel
- *
- * @param subtask - The subtask to evaluate
- * @param config - Swarm configuration with model preferences
- * @returns Model identifier string
- */
-export function selectWorkerModel(
-  subtask: DecomposedSubtask & { model?: string },
-  config: SwarmConfig,
-): string {
-  // Priority 1: Explicit model in subtask
-  if (subtask.model) {
-    return subtask.model;
-  }
-
-  const files = subtask.files || [];
-
-  // Priority 2: File-type inference
-  if (files.length > 0) {
-    const allDocs = files.every((f) => {
-      const lower = f.toLowerCase();
-      return lower.endsWith(".md") || lower.endsWith(".mdx");
-    });
-
-    const allTests = files.every((f) => {
-      const lower = f.toLowerCase();
-      return lower.includes(".test.") || lower.includes(".spec.");
-    });
-
-    if (allDocs || allTests) {
-      // Use lite model if configured, otherwise fall back to primary
-      return config.liteModel || config.primaryModel || "anthropic/claude-haiku-4-5";
-    }
-  }
-
-  // Priority 3: Default to primary model
-  return config.primaryModel || "anthropic/claude-haiku-4-5";
-}

package/src/observability-tools.test.ts

@@ -1,359 +0,0 @@
-/**
- * Observability Tools Tests
- *
- * TDD: Write tests first, then implement the tools.
- */
-
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import {
-	observabilityTools,
-	type SwarmAnalyticsArgs,
-	type SwarmQueryArgs,
-	type SwarmDiagnoseArgs,
-	type SwarmInsightsArgs,
-} from "./observability-tools";
-import type { ToolContext } from "@opencode-ai/plugin";
-import {
-	closeSwarmMailLibSQL,
-	createInMemorySwarmMailLibSQL,
-	initSwarmAgent,
-	reserveSwarmFiles,
-	sendSwarmMessage,
-	type SwarmMailAdapter,
-} from "swarm-mail";
-
-describe("observability-tools", () => {
-	let swarmMail: SwarmMailAdapter;
-	const projectPath = "/test/project";
-	const mockContext: ToolContext = { sessionID: "test-session" };
-
-	beforeAll(async () => {
-		// Create in-memory database with test data
-		swarmMail = await createInMemorySwarmMailLibSQL(projectPath);
-
-		// Populate with test events using high-level API
-		const agentName = "TestAgent";
-
-		// Register agent
-		await initSwarmAgent({
-			projectPath,
-			agentName,
-			taskDescription: "test-task",
-		});
-
-		// Reserve and release files (for lock contention analytics)
-		await reserveSwarmFiles({
-			projectPath,
-			agentName,
-			paths: ["src/test.ts"],
-			reason: "test-reason",
-		});
-
-		// Send a message (for message latency analytics)
-		await sendSwarmMessage({
-			projectPath,
-			fromAgent: agentName,
-			toAgents: ["Agent2"],
-			subject: "test-subject",
-			body: "test-body",
-		});
-
-		// Note: subtask outcomes are recorded via a different API
-		// For now, we'll test with the events we have
-		// The important thing is that the tools can execute queries
-	});
-
-	afterAll(async () => {
-		await closeSwarmMailLibSQL(projectPath);
-	});
-
-	describe("swarm_analytics", () => {
-		const tool = observabilityTools.swarm_analytics;
-
-		test("is defined with correct schema", () => {
-			expect(tool).toBeDefined();
-			expect(tool.description).toBeTruthy();
-			expect(tool.args).toBeDefined();
-		});
-
-		test("returns failed-decompositions data", async () => {
-			const args: SwarmAnalyticsArgs = {
-				query: "failed-decompositions",
-			};
-
-			const result = await tool.execute(args, mockContext);
-			expect(result).toBeTruthy();
-
-			const parsed = JSON.parse(result);
-			expect(parsed).toHaveProperty("results");
-			expect(Array.isArray(parsed.results)).toBe(true);
-			// Empty data is fine - we're testing tool execution
-		});
-
-		test("returns strategy-success-rates data", async () => {
-			const args: SwarmAnalyticsArgs = {
-				query: "strategy-success-rates",
-			};
-
-			const result = await tool.execute(args, mockContext);
-			const parsed = JSON.parse(result);
-			expect(parsed).toHaveProperty("results");
-			expect(Array.isArray(parsed.results)).toBe(true);
-		});
-
-		test("returns agent-activity data", async () => {
-			const args: SwarmAnalyticsArgs = {
-				query: "agent-activity",
-			};
-
-			const result = await tool.execute(args, mockContext);
-			const parsed = JSON.parse(result);
-			expect(parsed).toHaveProperty("results");
-			expect(Array.isArray(parsed.results)).toBe(true);
-			// Should have at least our TestAgent
-			expect(parsed.results.length).toBeGreaterThanOrEqual(1);
-		});
-
-		test("supports summary format", async () => {
-			const args: SwarmAnalyticsArgs = {
-				query: "agent-activity",
-				format: "summary",
-			};
-
-			const result = await tool.execute(args, mockContext);
-			expect(result).toBeTruthy();
-			expect(typeof result).toBe("string");
-			// Summary should be concise (<500 chars)
-			expect(result.length).toBeLessThan(500);
-		});
-
-		test("supports time filtering with since", async () => {
-			const args: SwarmAnalyticsArgs = {
-				query: "agent-activity",
-				since: "24h",
-			};
-
-			const result = await tool.execute(args, mockContext);
-			const parsed = JSON.parse(result);
-			expect(parsed).toHaveProperty("results");
-		});
-
-		test("returns error for invalid query type", async () => {
-			const args = {
-				query: "invalid-query",
-			};
-
-			const result = await tool.execute(args as any, mockContext);
-			const parsed = JSON.parse(result);
-			expect(parsed).toHaveProperty("error");
-		});
-	});
-
-	describe("swarm_query", () => {
-		const tool = observabilityTools.swarm_query;
-
-		test("is defined with correct schema", () => {
-			expect(tool).toBeDefined();
-			expect(tool.description).toBeTruthy();
-			expect(tool.args).toBeDefined();
-		});
-
-		test("executes raw SQL queries", async () => {
-			const args: SwarmQueryArgs = {
-				sql: "SELECT type, COUNT(*) as count FROM events GROUP BY type",
-			};
-
-			const result = await tool.execute(args, mockContext);
-			expect(result).toBeTruthy();
-
-			const parsed = JSON.parse(result);
-			// May have errors in test environment - that's ok
-			if (!parsed.error) {
-				// Should have count and results even if empty
-				expect(parsed).toHaveProperty("count");
-				expect(parsed).toHaveProperty("results");
-				expect(Array.isArray(parsed.results)).toBe(true);
-			}
-		});
-
-		test("limits results to max 50 rows", async () => {
-			const args: SwarmQueryArgs = {
-				sql: "SELECT * FROM events LIMIT 100", // Try to fetch 100
-			};
-
-			const result = await tool.execute(args, mockContext);
-			const parsed = JSON.parse(result);
-			// Should be capped at 50 (or less if there's less data)
-			// May return error if database issues - that's ok for this test
-			if (parsed.error) {
-				expect(parsed).toHaveProperty("error");
-			} else {
-				expect(parsed).toHaveProperty("results");
-				expect(parsed.results.length).toBeLessThanOrEqual(50);
-			}
-		});
-
-		test("supports table format", async () => {
-			const args: SwarmQueryArgs = {
-				sql: "SELECT type FROM events LIMIT 3",
-				format: "table",
-			};
-
-			const result = await tool.execute(args, mockContext);
-			expect(typeof result).toBe("string");
-			// Table format returns string (even if "No results" for empty data)
-			expect(result.length).toBeGreaterThan(0);
-		});
-
-		test("returns error for invalid SQL", async () => {
-			const args: SwarmQueryArgs = {
-				sql: "SELECT * FROM nonexistent_table",
-			};
-
-			const result = await tool.execute(args, mockContext);
-			const parsed = JSON.parse(result);
-			expect(parsed).toHaveProperty("error");
-		});
-	});
-
-	describe("swarm_diagnose", () => {
-		const tool = observabilityTools.swarm_diagnose;
-
-		test("is defined with correct schema", () => {
-			expect(tool).toBeDefined();
-			expect(tool.description).toBeTruthy();
-			expect(tool.args).toBeDefined();
-		});
-
-		test("diagnoses issues for a specific epic", async () => {
-			const args: SwarmDiagnoseArgs = {
-				epic_id: "epic-123",
-				include: ["blockers", "errors"],
-			};
-
-			const result = await tool.execute(args, mockContext);
-			expect(result).toBeTruthy();
-
-			const parsed = JSON.parse(result);
-			expect(parsed).toHaveProperty("epic_id");
-			expect(parsed).toHaveProperty("diagnosis");
-		});
-
-		test("returns structured diagnosis with suggestions", async () => {
-			const args: SwarmDiagnoseArgs = {
-				bead_id: "task-1",
-			};
-
-			const result = await tool.execute(args, mockContext);
-			const parsed = JSON.parse(result);
-			expect(parsed).toHaveProperty("diagnosis");
-			expect(Array.isArray(parsed.diagnosis)).toBe(true);
-		});
-
-		test("includes timeline when requested", async () => {
-			const args: SwarmDiagnoseArgs = {
-				bead_id: "task-1",
-				include: ["timeline"],
-			};
-
-			const result = await tool.execute(args, mockContext);
-			const parsed = JSON.parse(result);
-			expect(parsed).toHaveProperty("timeline");
-		});
-	});
-
-	describe("swarm_insights", () => {
-		const tool = observabilityTools.swarm_insights;
-
-		test("is defined with correct schema", () => {
-			expect(tool).toBeDefined();
-			expect(tool.description).toBeTruthy();
-			expect(tool.args).toBeDefined();
-		});
-
-		test("generates insights for recent activity", async () => {
-			const args: SwarmInsightsArgs = {
-				scope: "recent",
-				metrics: ["success_rate", "avg_duration"],
-			};
-
-			const result = await tool.execute(args, mockContext);
-			expect(result).toBeTruthy();
-
-			const parsed = JSON.parse(result);
-			expect(parsed).toHaveProperty("insights");
-			expect(Array.isArray(parsed.insights)).toBe(true);
-		});
-
-		test("generates insights for specific epic", async () => {
-			const args: SwarmInsightsArgs = {
-				scope: "epic",
-				epic_id: "epic-123",
-				metrics: ["conflict_rate", "retry_rate"],
-			};
-
-			const result = await tool.execute(args, mockContext);
-			const parsed = JSON.parse(result);
-			expect(parsed).toHaveProperty("epic_id", "epic-123");
-			expect(parsed).toHaveProperty("insights");
-		});
-
-		test("returns error when epic_id missing for epic scope", async () => {
-			const args: SwarmInsightsArgs = {
-				scope: "epic",
-				metrics: ["success_rate"],
-				// Missing epic_id
-			};
-
-			const result = await tool.execute(args, mockContext);
-			const parsed = JSON.parse(result);
-			expect(parsed).toHaveProperty("error");
-		});
-	});
-
-	describe("integration with swarm-mail analytics", () => {
-		test("all query types are supported", async () => {
-			const queryTypes = [
-				"failed-decompositions",
-				"strategy-success-rates",
-				"lock-contention",
-				"agent-activity",
-				"message-latency",
-				"scope-violations",
-				"task-duration",
-				"checkpoint-frequency",
-				"recovery-success",
-				"human-feedback",
-			];
-
-			for (const queryType of queryTypes) {
-				const tool = observabilityTools.swarm_analytics;
-				const args: SwarmAnalyticsArgs = {
-					query: queryType as SwarmAnalyticsArgs["query"],
-				};
-
-				const result = await tool.execute(args, mockContext);
-				const parsed = JSON.parse(result);
-
-				// Should return results property (even if empty array)
-				// May have errors in test environment - that's ok
-				if (!parsed.error) {
-					expect(parsed).toHaveProperty("results");
-				}
-			}
-		});
-	});
-
-	describe("CLI Stats Helpers", () => {
-		// These helpers will be exported for use in bin/swarm.ts
-		// They format analytics data for beautiful CLI output
-
-		describe("formatSwarmStatsBox", () => {
-			test("formats stats in a beautiful box", () => {
-				// This will be implemented in observability-tools.ts
-				// Just defining the test structure for now
-				expect(true).toBe(true);
-			});
-		});
-	});
-});