opencode-swarm-plugin 0.42.5 → 0.42.6

package/src/swarm-prompts.test.ts

@@ -1102,4 +1102,169 @@ describe("getPromptInsights", () => {
       }
     });
   });
+
+  describe("getPromptInsights integration with swarm-insights", () => {
+    test("coordinator role uses swarm-insights data layer", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      
+      // Should call new data layer, not old swarm-mail analytics
+      const result = await getPromptInsights({ role: "coordinator" });
+      
+      // If we have data, it should be formatted by formatInsightsForPrompt
+      if (result.length > 0) {
+        // New format has "Historical Insights" section
+        expect(result).toMatch(/Historical Insights|Strategy Performance|Common Pitfalls/i);
+      }
+    });
+
+    test("coordinator insights have expected structure when data exists", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ role: "coordinator" });
+      
+      // Should have Historical Insights header
+      if (result.length > 0) {
+        expect(result).toContain("📊 Historical Insights");
+        expect(result).toContain("Use these learnings when selecting decomposition strategies");
+      }
+    });
+
+    test("coordinator insights use formatInsightsForPrompt output", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ role: "coordinator" });
+      
+      // formatInsightsForPrompt produces specific markdown patterns
+      if (result.length > 0 && result.includes("Strategy")) {
+        // Should have Strategy Performance or Common Pitfalls sections
+        const hasExpectedSections = 
+          result.includes("Strategy Performance") || 
+          result.includes("Common Pitfalls");
+        expect(hasExpectedSections).toBe(true);
+      }
+    });
+
+    test("coordinator insights are concise (<500 tokens)", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ role: "coordinator" });
+      
+      // formatInsightsForPrompt enforces maxTokens=500 by default
+      // Rough estimate: 4 chars per token = 2000 chars max
+      if (result.length > 0) {
+        expect(result.length).toBeLessThan(2000);
+      }
+    });
+
+    test("gracefully handles missing data", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      
+      // Should not throw if database is empty or missing
+      const result = await getPromptInsights({ role: "coordinator" });
+      
+      // Empty string is acceptable when no data
+      expect(typeof result).toBe("string");
+    });
+
+    test("imports from swarm-insights module", async () => {
+      // Verify the imports exist
+      const insights = await import("./swarm-insights");
+      
+      expect(insights.getStrategyInsights).toBeDefined();
+      expect(insights.getPatternInsights).toBeDefined();
+      expect(insights.formatInsightsForPrompt).toBeDefined();
+    });
+  });
+
+  describe("worker insights integration with swarm-insights", () => {
+    test("worker role uses getFileInsights from swarm-insights data layer", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      
+      // Should call getFileInsights for file-specific insights
+      const result = await getPromptInsights({ 
+        role: "worker",
+        files: ["src/auth.ts", "src/db.ts"],
+        domain: "authentication"
+      });
+      
+      // If we have data, it should be formatted by formatInsightsForPrompt
+      if (result.length > 0) {
+        // New format has "File-Specific Gotchas" or semantic memory learnings
+        expect(result).toMatch(/File-Specific Gotchas|Relevant Learnings/i);
+      }
+    });
+
+    test("worker insights include file-specific gotchas when available", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ 
+        role: "worker",
+        files: ["src/test-file.ts"],
+      });
+      
+      // Should contain either file gotchas or semantic memory results
+      if (result.length > 0) {
+        const hasFileInsights = 
+          result.includes("File-Specific Gotchas") ||
+          result.includes("Relevant Learnings");
+        expect(hasFileInsights).toBe(true);
+      }
+    });
+
+    test("worker insights combine event store failures + semantic memory", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ 
+        role: "worker",
+        files: ["src/complex.ts"],
+        domain: "complex feature"
+      });
+      
+      // Should potentially have both sources of insight
+      // At minimum, should return string (empty if no data)
+      expect(typeof result).toBe("string");
+    });
+
+    test("worker insights are concise (<300 tokens per file)", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      const result = await getPromptInsights({ 
+        role: "worker",
+        files: ["src/file1.ts", "src/file2.ts", "src/file3.ts"],
+      });
+      
+      // <300 tokens per file = 900 tokens max for 3 files
+      // Rough estimate: 4 chars per token = 3600 chars max
+      if (result.length > 0) {
+        expect(result.length).toBeLessThan(3600);
+      }
+    });
+
+    test("formatSubtaskPromptV2 includes file insights in shared_context", async () => {
+      const result = await formatSubtaskPromptV2({
+        bead_id: "test-123",
+        epic_id: "epic-456",
+        subtask_title: "Implement auth",
+        subtask_description: "Add authentication flow",
+        files: ["src/auth.ts", "src/user.ts"],
+        shared_context: "Original context from coordinator",
+      });
+      
+      // shared_context should be replaced and insights potentially included
+      // At minimum, the original context should be in the prompt
+      expect(result).toContain("Original context from coordinator");
+    });
+
+    test("worker insights gracefully handle missing files parameter", async () => {
+      const { getPromptInsights } = await import("./swarm-prompts");
+      
+      // Should not throw with no files or domain
+      const result = await getPromptInsights({ role: "worker" });
+      
+      // Empty string is acceptable when no context to query
+      expect(typeof result).toBe("string");
+    });
+
+    test("worker insights use swarm-insights getFileInsights", async () => {
+      // Verify the function is imported
+      const insights = await import("./swarm-insights");
+      
+      expect(insights.getFileInsights).toBeDefined();
+      expect(typeof insights.getFileInsights).toBe("function");
+    });
+  });
 });

package/src/swarm-prompts.ts

@@ -1188,8 +1188,9 @@ export async function getPromptInsights(
  */
 async function getCoordinatorInsights(project_key?: string): Promise<string> {
   try {
-    // Import swarm-mail and analytics
-    const { createLibSQLAdapter, createSwarmMailAdapter, strategySuccessRates } = await import("swarm-mail");
+    // Import swarm-mail and swarm-insights modules
+    const { createLibSQLAdapter, createSwarmMailAdapter } = await import("swarm-mail");
+    const { getStrategyInsights, getPatternInsights, formatInsightsForPrompt } = await import("./swarm-insights.js");
     
     // Create libSQL database adapter
     const dbAdapter = await createLibSQLAdapter({ url: "file:./.swarm-mail/streams.db" });
@@ -1197,48 +1198,32 @@ async function getCoordinatorInsights(project_key?: string): Promise<string> {
     // Create swarm-mail adapter with database
     const adapter = createSwarmMailAdapter(dbAdapter, project_key || "default");
     
-    // Get database for raw queries
-    const db = await adapter.getDatabase();
+    // Query insights from the new data layer
+    const [strategies, patterns] = await Promise.all([
+      getStrategyInsights(adapter, ""),
+      getPatternInsights(adapter),
+    ]);
     
-    // Query strategy success rates
-    const query = strategySuccessRates({ project_key });
-    const result = await db.query(query.sql, Object.values(query.parameters || {}));
+    // Bundle insights
+    const bundle = {
+      strategies,
+      patterns,
+    };
+    
+    // Format for prompt injection (<500 tokens)
+    const formatted = formatInsightsForPrompt(bundle, { maxTokens: 500 });
     
-    if (!result || !result.rows || result.rows.length === 0) {
+    if (!formatted) {
       return "";
     }
     
-    // Format as markdown table
-    const rows = result.rows.map((r: any) => {
-      const strategy = r.strategy || "unknown";
-      const total = r.total_attempts || 0;
-      const successRate = r.success_rate || 0;
-      const emoji = successRate >= 80 ? "✅" : successRate >= 60 ? "⚠️" : "❌";
-      
-      return `| ${emoji} ${strategy} | ${successRate.toFixed(1)}% | ${total} |`;
-    });
-    
-    // Limit to top 5 strategies to prevent context bloat
-    const topRows = rows.slice(0, 5);
-    
-    // Add anti-pattern hints for low-success strategies
-    const antiPatterns = result.rows
-      .filter((r: any) => r.success_rate < 60)
-      .map((r: any) => `- AVOID: ${r.strategy} strategy (${r.success_rate.toFixed(1)}% success rate)`)
-      .slice(0, 3);
-    
-    const antiPatternsSection = antiPatterns.length > 0
-      ? `\n\n**Anti-Patterns:**\n${antiPatterns.join("\n")}`
-      : "";
-    
+    // Add section header
     return `
-## 📊 Swarm Insights (Strategy Success Rates)
+## 📊 Historical Insights
 
-| Strategy | Success Rate | Total Attempts |
-|----------|--------------|----------------|
-${topRows.join("\n")}
+${formatted}
 
-**Use these insights to select decomposition strategies.**${antiPatternsSection}
+**Use these learnings when selecting decomposition strategies and planning subtasks.**
 `;
   } catch (e) {
     console.warn("Failed to get coordinator insights:", e);
@@ -1254,7 +1239,10 @@ async function getWorkerInsights(
   domain?: string,
 ): Promise<string> {
   try {
-    const adapter = await getMemoryAdapter();
+    // Import swarm-mail and swarm-insights modules
+    const { createLibSQLAdapter, createSwarmMailAdapter } = await import("swarm-mail");
+    const { getFileInsights, formatInsightsForPrompt } = await import("./swarm-insights.js");
+    const memoryAdapter = await getMemoryAdapter();
     
     // Build query from files and domain
     let query = "";
@@ -1270,31 +1258,61 @@ async function getWorkerInsights(
       return ""; // No context to query
     }
     
-    // Query semantic memory for relevant learnings
-    const result = await adapter.find({
-      query: `${query} gotcha pitfall pattern bug`,
-      limit: 3,
-    });
+    // Query BOTH event store (via swarm-insights) AND semantic memory
+    const [fileInsights, memoryResult] = await Promise.all([
+      // Get file-specific insights from event store
+      (async () => {
+        if (!files || files.length === 0) return [];
+        try {
+          const dbAdapter = await createLibSQLAdapter({ url: "file:./.swarm-mail/streams.db" });
+          const swarmMail = createSwarmMailAdapter(dbAdapter, "default");
+          return await getFileInsights(swarmMail, files);
+        } catch (e) {
+          console.warn("Failed to get file insights from event store:", e);
+          return [];
+        }
+      })(),
+      
+      // Get domain/file learnings from semantic memory
+      memoryAdapter.find({
+        query: `${query} gotcha pitfall pattern bug`,
+        limit: 3,
+      }),
+    ]);
     
-    if (result.count === 0) {
-      return "";
-    }
+    // Bundle insights for formatting
+    const bundle = {
+      files: fileInsights,
+    };
     
-    // Format as bullet list
-    const learnings = result.results.map((r) => {
-      const content = r.content.length > 150
-        ? r.content.slice(0, 150) + "..."
-        : r.content;
-      return `- ${content}`;
-    });
+    // Format file insights using swarm-insights formatter
+    const formattedFileInsights = formatInsightsForPrompt(bundle, { maxTokens: 300 });
     
-    return `
-## 💡 Relevant Learnings (from past agents)
+    // Format semantic memory learnings
+    let formattedMemory = "";
+    if (memoryResult.count > 0) {
+      const learnings = memoryResult.results.map((r) => {
+        const content = r.content.length > 150
+          ? r.content.slice(0, 150) + "..."
+          : r.content;
+        return `- ${content}`;
+      });
+      
+      formattedMemory = `## 💡 Relevant Learnings (from past agents)
 
 ${learnings.join("\n")}
 
-**Check semantic-memory for full details if needed.**
-`;
+**Check semantic-memory for full details if needed.**`;
+    }
+    
+    // Combine both sources
+    const sections = [formattedFileInsights, formattedMemory].filter(s => s.length > 0);
+    
+    if (sections.length === 0) {
+      return "";
+    }
+    
+    return sections.join("\n\n");
   } catch (e) {
     console.warn("Failed to get worker insights:", e);
     return "";