opencode-swarm-plugin 0.43.0 → 0.44.1

package/src/swarm-deferred.integration.test.ts

@@ -1,157 +0,0 @@
-/**
- * Swarm DurableDeferred Integration Tests
- *
- * Tests cross-agent task completion signaling using DurableDeferred.
- * Workers resolve a deferred when completing, coordinators await it.
- */
-import { beforeAll, describe, expect, it } from "bun:test";
-import { Effect, pipe } from "effect";
-import type { DatabaseAdapter } from "../../swarm-mail/src/types/database";
-import type { SwarmMailAdapter } from "../../swarm-mail/src/adapter";
-import { createInMemorySwarmMailLibSQL } from "../../swarm-mail/src/libsql.convenience";
-import { DurableDeferredLive } from "../../swarm-mail/src/streams/effect/deferred";
-import { swarm_complete } from "./swarm-orchestrate";
-
-describe("swarm_complete DurableDeferred integration", () => {
-  let swarmMail: SwarmMailAdapter;
-  let db: DatabaseAdapter;
-  let projectKey: string;
-
-  beforeAll(async () => {
-    // Use in-memory libSQL database
-    swarmMail = await createInMemorySwarmMailLibSQL("test-deferred-integration");
-    db = await swarmMail.getDatabase();
-    projectKey = "/tmp/test-deferred-integration";
-
-    // Register test agent using swarm-mail adapter
-    await swarmMail.registerAgent(projectKey, "TestWorker");
-
-    // Create test bead using swarm-mail Hive adapter
-    await swarmMail.createCell(projectKey, {
-      title: "Test Task",
-      type: "task",
-      priority: 2,
-      status: "in_progress",
-      id: "test-bead-123",
-    });
-  });
-
-  it("should resolve deferred when swarm_complete is called", async () => {
-    const beadId = "test-bead-123";
-
-    // First create deferred (coordinator side)
-    const createProgram = Effect.gen(function* () {
-      const DurableDeferred = yield* Effect.serviceOption(DurableDeferredLive);
-      expect(DurableDeferred._tag).toBe("Some");
-      
-      if (DurableDeferred._tag !== "Some") {
-        throw new Error("DurableDeferred service not available");
-      }
-
-      const service = DurableDeferred.value;
-      
-      // Create deferred keyed by bead_id
-      const handle = yield* service.create({
-        ttlSeconds: 60,
-        db,
-      });
-
-      expect(handle.url).toMatch(/^deferred:/);
-      
-      return handle.url;
-    });
-
-    const deferredUrl = await Effect.runPromise(
-      pipe(createProgram, Effect.provide(DurableDeferredLive))
-    );
-
-    // Worker completes the task (this should resolve the deferred)
-    const mockContext = {
-      sessionID: "test-session",
-      messageID: "test-message",
-      agent: "test-agent",
-      abort: new AbortController().signal,
-    };
-
-    const completeResult = await swarm_complete.execute(
-      {
-        project_key: projectKey,
-        agent_name: "TestWorker",
-        bead_id: beadId,
-        summary: "Task completed successfully",
-        skip_verification: true, // Skip UBS/typecheck for test
-      },
-      mockContext
-    );
-
-    const parsed = JSON.parse(completeResult);
-    expect(parsed.success).toBe(true);
-
-    // TODO: Resolve the deferred in swarm_complete implementation
-    // For now, manually resolve to verify await works
-    const resolveProgram = Effect.gen(function* () {
-      const DurableDeferred = yield* Effect.serviceOption(DurableDeferredLive);
-      if (DurableDeferred._tag !== "Some") {
-        throw new Error("DurableDeferred service not available");
-      }
-
-      const service = DurableDeferred.value;
-      yield* service.resolve(deferredUrl, { completed: true }, db);
-    });
-
-    await Effect.runPromise(
-      pipe(resolveProgram, Effect.provide(DurableDeferredLive))
-    );
-
-    // Coordinator awaits completion
-    const awaitProgram = Effect.gen(function* () {
-      const DurableDeferred = yield* Effect.serviceOption(DurableDeferredLive);
-      if (DurableDeferred._tag !== "Some") {
-        throw new Error("DurableDeferred service not available");
-      }
-
-      const service = DurableDeferred.value;
-      const result = yield* service.await(deferredUrl, 60, db);
-      
-      expect(result).toEqual({ completed: true });
-      return result;
-    });
-
-    const result = await Effect.runPromise(
-      pipe(awaitProgram, Effect.provide(DurableDeferredLive))
-    );
-
-    expect(result).toEqual({ completed: true });
-  });
-
-  it("should timeout if deferred is never resolved", async () => {
-    const program = Effect.gen(function* () {
-      const DurableDeferred = yield* Effect.serviceOption(DurableDeferredLive);
-      expect(DurableDeferred._tag).toBe("Some");
-      
-      if (DurableDeferred._tag !== "Some") {
-        throw new Error("DurableDeferred service not available");
-      }
-
-      const service = DurableDeferred.value;
-      
-      // Create deferred with short timeout
-      const handle = yield* service.create({
-        ttlSeconds: 1,
-        db,
-      });
-
-      // Don't resolve it - just await
-      const result = yield* handle.value;
-      
-      return result;
-    });
-
-    // Should timeout and throw TimeoutError
-    await expect(
-      Effect.runPromise(
-        pipe(program, Effect.provide(DurableDeferredLive))
-      )
-    ).rejects.toThrow(/timed out/);
-  });
-});

package/src/swarm-deferred.test.ts

@@ -1,38 +0,0 @@
-/**
- * Swarm DurableDeferred Unit Tests
- *
- * Tests that swarm_complete resolves a deferred for cross-agent signaling.
- */
-import { describe, expect, it } from "bun:test";
-
-describe("swarm_complete DurableDeferred integration", () => {
-  it("should add deferred_resolved to response when deferred exists", () => {
-    // This is a regression test - ensures the new fields are in the response
-    // The actual database integration is tested in swarm-deferred.integration.test.ts
-    
-    const mockResponse = {
-      success: true,
-      bead_id: "test-bead-123",
-      closed: true,
-      reservations_released: true,
-      deferred_resolved: true,  // NEW FIELD
-      deferred_error: undefined, // NEW FIELD
-    };
-
-    expect(mockResponse.deferred_resolved).toBe(true);
-    expect(mockResponse).toHaveProperty("deferred_error");
-  });
-
-  it("should handle deferred_error when resolution fails", () => {
-    const mockResponse = {
-      success: true,
-      bead_id: "test-bead-123",
-      closed: true,
-      deferred_resolved: false,
-      deferred_error: "Database not available",
-    };
-
-    expect(mockResponse.deferred_resolved).toBe(false);
-    expect(mockResponse.deferred_error).toBe("Database not available");
-  });
-});

package/src/swarm-insights.test.ts

@@ -1,214 +0,0 @@
-/**
- * Swarm Insights Data Layer Tests
- *
- * TDD: Red → Green → Refactor
- */
-
-import { describe, expect, test, beforeAll, afterAll } from "bun:test";
-import {
-	getStrategyInsights,
-	getFileInsights,
-	getPatternInsights,
-	formatInsightsForPrompt,
-	type StrategyInsight,
-	type FileInsight,
-	type PatternInsight,
-} from "./swarm-insights";
-import { createInMemorySwarmMail, type SwarmMailAdapter } from "swarm-mail";
-
-describe("swarm-insights data layer", () => {
-	let swarmMail: SwarmMailAdapter;
-
-	beforeAll(async () => {
-		swarmMail = await createInMemorySwarmMail("test-insights");
-	});
-
-	afterAll(async () => {
-		await swarmMail.close();
-	});
-
-	describe("getStrategyInsights", () => {
-		test("returns empty array when no data", async () => {
-			const insights = await getStrategyInsights(swarmMail, "test-task");
-			expect(insights).toEqual([]);
-		});
-
-		test("returns strategy success rates from outcomes", async () => {
-			// Seed some outcome events (id is auto-increment, timestamp is integer)
-			const db = await swarmMail.getDatabase();
-			const now = Date.now();
-			await db.query(
-				`INSERT INTO events (type, project_key, timestamp, data) VALUES 
-				('subtask_outcome', 'test', ?, ?),
-				('subtask_outcome', 'test', ?, ?),
-				('subtask_outcome', 'test', ?, ?)`,
-				[
-					now,
-					JSON.stringify({ strategy: "file-based", success: "true" }),
-					now,
-					JSON.stringify({ strategy: "file-based", success: "true" }),
-					now,
-					JSON.stringify({ strategy: "file-based", success: "false" }),
-				],
-			);
-
-			const insights = await getStrategyInsights(swarmMail, "test-task");
-
-			expect(insights.length).toBeGreaterThan(0);
-			const fileBased = insights.find((i) => i.strategy === "file-based");
-			expect(fileBased).toBeDefined();
-			expect(fileBased?.successRate).toBeCloseTo(66.67, 0);
-			expect(fileBased?.totalAttempts).toBe(3);
-		});
-
-		test("includes recommendation based on success rate", async () => {
-			const insights = await getStrategyInsights(swarmMail, "test-task");
-			const fileBased = insights.find((i) => i.strategy === "file-based");
-
-			expect(fileBased?.recommendation).toBeDefined();
-			expect(typeof fileBased?.recommendation).toBe("string");
-		});
-	});
-
-	describe("getFileInsights", () => {
-		test("returns empty array for unknown files", async () => {
-			const insights = await getFileInsights(swarmMail, [
-				"src/unknown-file.ts",
-			]);
-			expect(insights).toEqual([]);
-		});
-
-		test("returns past issues for known files", async () => {
-			// Seed some file-related events (id is auto-increment, timestamp is integer)
-			const db = await swarmMail.getDatabase();
-			const now = Date.now();
-			await db.query(
-				`INSERT INTO events (type, project_key, timestamp, data) VALUES 
-				('subtask_outcome', 'test', ?, ?)`,
-				[
-					now,
-					JSON.stringify({
-						files_touched: ["src/auth.ts"],
-						success: "false",
-						error_count: 2,
-					}),
-				],
-			);
-
-			const insights = await getFileInsights(swarmMail, ["src/auth.ts"]);
-
-			expect(insights.length).toBeGreaterThan(0);
-			const authInsight = insights.find((i) => i.file === "src/auth.ts");
-			expect(authInsight).toBeDefined();
-			expect(authInsight?.failureCount).toBeGreaterThan(0);
-		});
-
-		test("includes gotchas from semantic memory", async () => {
-			// This would query semantic memory for file-specific learnings
-			const insights = await getFileInsights(swarmMail, ["src/auth.ts"]);
-
-			// Even if no gotchas, the structure should be correct
-			const authInsight = insights.find((i) => i.file === "src/auth.ts");
-			expect(authInsight?.gotchas).toBeDefined();
-			expect(Array.isArray(authInsight?.gotchas)).toBe(true);
-		});
-	});
-
-	describe("getPatternInsights", () => {
-		test("returns common failure patterns", async () => {
-			const insights = await getPatternInsights(swarmMail);
-
-			expect(Array.isArray(insights)).toBe(true);
-			// Structure check
-			if (insights.length > 0) {
-				expect(insights[0]).toHaveProperty("pattern");
-				expect(insights[0]).toHaveProperty("frequency");
-				expect(insights[0]).toHaveProperty("recommendation");
-			}
-		});
-
-		test("includes anti-patterns from learning system", async () => {
-			const insights = await getPatternInsights(swarmMail);
-
-			// Should include anti-patterns if any exist
-			expect(Array.isArray(insights)).toBe(true);
-		});
-	});
-
-	describe("formatInsightsForPrompt", () => {
-		test("formats strategy insights concisely", () => {
-			const strategies: StrategyInsight[] = [
-				{
-					strategy: "file-based",
-					successRate: 85,
-					totalAttempts: 20,
-					recommendation: "Preferred for this project",
-				},
-				{
-					strategy: "feature-based",
-					successRate: 60,
-					totalAttempts: 10,
-					recommendation: "Use with caution",
-				},
-			];
-
-			const formatted = formatInsightsForPrompt({ strategies });
-
-			expect(formatted).toContain("file-based");
-			expect(formatted).toContain("85%");
-			expect(formatted.length).toBeLessThan(500); // Context-efficient
-		});
-
-		test("formats file insights concisely", () => {
-			const files: FileInsight[] = [
-				{
-					file: "src/auth.ts",
-					failureCount: 3,
-					lastFailure: "2025-12-25",
-					gotchas: ["Watch for race conditions in token refresh"],
-				},
-			];
-
-			const formatted = formatInsightsForPrompt({ files });
-
-			expect(formatted).toContain("src/auth.ts");
-			expect(formatted).toContain("race conditions");
-			expect(formatted.length).toBeLessThan(300); // Per-file budget
-		});
-
-		test("formats pattern insights concisely", () => {
-			const patterns: PatternInsight[] = [
-				{
-					pattern: "Missing error handling",
-					frequency: 5,
-					recommendation: "Add try/catch around async operations",
-				},
-			];
-
-			const formatted = formatInsightsForPrompt({ patterns });
-
-			expect(formatted).toContain("Missing error handling");
-			expect(formatted).toContain("try/catch");
-		});
-
-		test("respects token budget", () => {
-			// Create many insights
-			const strategies: StrategyInsight[] = Array.from({ length: 10 }, (_, i) => ({
-				strategy: `strategy-${i}`,
-				successRate: 50 + i * 5,
-				totalAttempts: 10,
-				recommendation: `Recommendation for strategy ${i}`,
-			}));
-
-			const formatted = formatInsightsForPrompt({ strategies }, { maxTokens: 200 });
-
-			// Should truncate to fit budget
-			expect(formatted.length).toBeLessThan(1000); // ~200 tokens ≈ 800 chars
-		});
-
-		test("returns empty string when no insights", () => {
-			const formatted = formatInsightsForPrompt({});
-			expect(formatted).toBe("");
-		});
-	});
-});