opencode-swarm-plugin 0.42.5 → 0.42.7

package/src/hive.integration.test.ts

@@ -17,6 +17,7 @@ import {
   hive_close,
   hive_start,
   hive_ready,
+  hive_cells,
   hive_link_thread,
   hive_sync,
   HiveError,
@@ -2133,4 +2134,108 @@ describe("beads integration", () => {
       }
     });
   });
+
+  describe("parent_id filter", () => {
+    it("hive_query filters by parent_id to get epic children", async () => {
+      const { rmSync } = await import("node:fs");
+      const tempProject = join(tmpdir(), `hive-parent-filter-${Date.now()}`);
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create an epic
+        const epicResponse = await hive_create.execute(
+          { title: "Epic Task", type: "epic", priority: 1 },
+          mockContext
+        );
+        const epic = parseResponse<Cell>(epicResponse);
+
+        // Create children of the epic
+        const child1Response = await hive_create.execute(
+          { title: "Subtask 1", type: "task", parent_id: epic.id },
+          mockContext
+        );
+        const child1 = parseResponse<Cell>(child1Response);
+
+        const child2Response = await hive_create.execute(
+          { title: "Subtask 2", type: "task", parent_id: epic.id },
+          mockContext
+        );
+        const child2 = parseResponse<Cell>(child2Response);
+
+        // Create unrelated cell
+        await hive_create.execute(
+          { title: "Unrelated Task", type: "task" },
+          mockContext
+        );
+
+        // Query by parent_id
+        const queryResponse = await hive_query.execute(
+          { parent_id: epic.id },
+          mockContext
+        );
+        const children = parseResponse<Cell[]>(queryResponse);
+
+        // Should only return the 2 children
+        expect(children).toHaveLength(2);
+        expect(children.map(c => c.id)).toContain(child1.id);
+        expect(children.map(c => c.id)).toContain(child2.id);
+        expect(children.every(c => c.parent_id === epic.id)).toBe(true);
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+
+    it("hive_cells filters by parent_id to get epic children", async () => {
+      const { rmSync } = await import("node:fs");
+      const tempProject = join(tmpdir(), `hive-cells-parent-filter-${Date.now()}`);
+      const originalDir = getHiveWorkingDirectory();
+      setHiveWorkingDirectory(tempProject);
+
+      try {
+        // Create an epic
+        const epicResponse = await hive_create.execute(
+          { title: "Epic with Children", type: "epic", priority: 1 },
+          mockContext
+        );
+        const epic = parseResponse<Cell>(epicResponse);
+
+        // Create children
+        const child1Response = await hive_create.execute(
+          { title: "Child A", type: "task", parent_id: epic.id },
+          mockContext
+        );
+        const child1 = parseResponse<Cell>(child1Response);
+
+        const child2Response = await hive_create.execute(
+          { title: "Child B", type: "bug", parent_id: epic.id },
+          mockContext
+        );
+        const child2 = parseResponse<Cell>(child2Response);
+
+        // Create unrelated cells
+        await hive_create.execute(
+          { title: "Orphan Task", type: "task" },
+          mockContext
+        );
+
+        // Query using hive_cells with parent_id
+        const cellsResponse = await hive_cells.execute(
+          { parent_id: epic.id },
+          mockContext
+        );
+        const cells = parseResponse<Cell[]>(cellsResponse);
+
+        // Should only return the 2 children
+        expect(cells).toHaveLength(2);
+        expect(cells.map(c => c.id)).toContain(child1.id);
+        expect(cells.map(c => c.id)).toContain(child2.id);
+        expect(cells.every(c => c.parent_id === epic.id)).toBe(true);
+      } finally {
+        setHiveWorkingDirectory(originalDir);
+        rmSync(tempProject, { recursive: true, force: true });
+      }
+    });
+  });
 });

package/src/hive.ts

@@ -873,6 +873,10 @@ export const hive_query = tool({
       .boolean()
       .optional()
       .describe("Only show unblocked cells"),
+    parent_id: tool.schema
+      .string()
+      .optional()
+      .describe("Filter by parent epic ID (returns children of an epic)"),
     limit: tool.schema
       .number()
       .optional()
@@ -893,6 +897,7 @@ export const hive_query = tool({
         cells = await adapter.queryCells(projectKey, {
           status: validated.status,
           type: validated.type,
+          parent_id: validated.parent_id,
           limit: validated.limit || 20,
         });
       }
@@ -1139,6 +1144,7 @@ USE THIS TOOL TO:
 - Find cells by type: hive_cells({ type: "bug" })
 - Get a specific cell by partial ID: hive_cells({ id: "mjkmd" })
 - Get the next ready (unblocked) cell: hive_cells({ ready: true })
+- Get children of an epic: hive_cells({ parent_id: "epic-id" })
 - Combine filters: hive_cells({ status: "open", type: "task" })
 
 RETURNS: Array of cells with id, title, status, priority, type, parent_id, created_at, updated_at
@@ -1152,6 +1158,7 @@ PREFER THIS OVER hive_query when you need to:
     id: tool.schema.string().optional().describe("Partial or full cell ID to look up"),
     status: tool.schema.enum(["open", "in_progress", "blocked", "closed"]).optional().describe("Filter by status"),
     type: tool.schema.enum(["task", "bug", "feature", "epic", "chore"]).optional().describe("Filter by type"),
+    parent_id: tool.schema.string().optional().describe("Filter by parent epic ID (returns children of an epic)"),
     ready: tool.schema.boolean().optional().describe("If true, return only the next unblocked cell"),
     limit: tool.schema.number().optional().describe("Max cells to return (default 20)"),
   },
@@ -1185,6 +1192,7 @@ PREFER THIS OVER hive_query when you need to:
       const cells = await adapter.queryCells(projectKey, {
         status: args.status,
         type: args.type,
+        parent_id: args.parent_id,
         limit: args.limit || 20,
       });
       

package/src/index.ts

@@ -515,6 +515,7 @@ export const allTools = {
   ...skillsTools,
   ...mandateTools,
   ...memoryTools,
+  ...observabilityTools,
 } as const;
 
 /**

package/src/schemas/cell.ts

@@ -122,6 +122,7 @@ export const CellQueryArgsSchema = z.object({
   status: CellStatusSchema.optional(),
   type: CellTypeSchema.optional(),
   ready: z.boolean().optional(),
+  parent_id: z.string().optional(),
   limit: z.number().int().positive().default(20),
 });
 export type CellQueryArgs = z.infer<typeof CellQueryArgsSchema>;

package/src/swarm-insights.test.ts

@@ -0,0 +1,214 @@
+/**
+ * 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("");
+		});
+	});
+});