opencode-swarm-plugin 0.42.5 → 0.42.7

package/dist/index.js

@@ -27652,6 +27652,178 @@ echo "Project directory: $1"
   };
 });
 
+// src/swarm-insights.ts
+var exports_swarm_insights = {};
+__export(exports_swarm_insights, {
+  getStrategyInsights: () => getStrategyInsights,
+  getPatternInsights: () => getPatternInsights,
+  getFileInsights: () => getFileInsights,
+  getCachedInsights: () => getCachedInsights,
+  formatInsightsForPrompt: () => formatInsightsForPrompt,
+  clearInsightsCache: () => clearInsightsCache
+});
+async function getStrategyInsights(swarmMail, _task) {
+  const db = await swarmMail.getDatabase();
+  const query = `
+		SELECT 
+			json_extract(data, '$.strategy') as strategy,
+			COUNT(*) as total_attempts,
+			SUM(CASE WHEN json_extract(data, '$.success') = 'true' THEN 1 ELSE 0 END) as successes
+		FROM events
+		WHERE type = 'subtask_outcome'
+		AND json_extract(data, '$.strategy') IS NOT NULL
+		GROUP BY json_extract(data, '$.strategy')
+		ORDER BY total_attempts DESC
+	`;
+  const result = await db.query(query, []);
+  const rows = result.rows;
+  return rows.map((row) => {
+    const successRate = row.successes / row.total_attempts * 100;
+    return {
+      strategy: row.strategy,
+      successRate: Math.round(successRate * 100) / 100,
+      totalAttempts: row.total_attempts,
+      recommendation: getStrategyRecommendation(row.strategy, successRate)
+    };
+  });
+}
+function getStrategyRecommendation(strategy, successRate) {
+  if (successRate >= 80) {
+    return `${strategy} is performing well (${successRate.toFixed(0)}% success)`;
+  }
+  if (successRate >= 60) {
+    return `${strategy} is moderate - monitor for issues`;
+  }
+  if (successRate >= 40) {
+    return `${strategy} has low success - consider alternatives`;
+  }
+  return `AVOID ${strategy} - high failure rate (${successRate.toFixed(0)}%)`;
+}
+async function getFileInsights(swarmMail, files) {
+  if (files.length === 0)
+    return [];
+  const db = await swarmMail.getDatabase();
+  const insights = [];
+  for (const file2 of files) {
+    const query = `
+			SELECT 
+				COUNT(*) as failure_count,
+				MAX(timestamp) as last_failure
+			FROM events
+			WHERE type = 'subtask_outcome'
+			AND json_extract(data, '$.success') = 'false'
+			AND json_extract(data, '$.files_touched') LIKE ?
+		`;
+    const result = await db.query(query, [`%${file2}%`]);
+    const row = result.rows[0];
+    if (row && row.failure_count > 0) {
+      const gotchas = await getFileGotchas(swarmMail, file2);
+      insights.push({
+        file: file2,
+        failureCount: row.failure_count,
+        lastFailure: row.last_failure,
+        gotchas
+      });
+    }
+  }
+  return insights;
+}
+async function getFileGotchas(_swarmMail, _file2) {
+  return [];
+}
+async function getPatternInsights(swarmMail) {
+  const db = await swarmMail.getDatabase();
+  const patterns = [];
+  const query = `
+		SELECT 
+			json_extract(data, '$.error_type') as error_type,
+			COUNT(*) as frequency
+		FROM events
+		WHERE type = 'subtask_outcome'
+		AND json_extract(data, '$.success') = 'false'
+		AND json_extract(data, '$.error_type') IS NOT NULL
+		GROUP BY json_extract(data, '$.error_type')
+		HAVING COUNT(*) >= 2
+		ORDER BY frequency DESC
+		LIMIT 5
+	`;
+  const result = await db.query(query, []);
+  const rows = result.rows;
+  for (const row of rows) {
+    patterns.push({
+      pattern: row.error_type,
+      frequency: row.frequency,
+      recommendation: getPatternRecommendation(row.error_type)
+    });
+  }
+  return patterns;
+}
+function getPatternRecommendation(errorType) {
+  const recommendations = {
+    type_error: "Add explicit type annotations and null checks",
+    timeout: "Consider breaking into smaller tasks",
+    conflict: "Check file reservations before editing",
+    test_failure: "Run tests incrementally during implementation"
+  };
+  return recommendations[errorType] || `Address ${errorType} issues`;
+}
+function formatInsightsForPrompt(bundle, options2 = {}) {
+  const { maxTokens = 500 } = options2;
+  const sections = [];
+  if (bundle.strategies && bundle.strategies.length > 0) {
+    const strategyLines = bundle.strategies.slice(0, 3).map((s) => `- ${s.strategy}: ${s.successRate.toFixed(0)}% success (${s.totalAttempts} attempts)`);
+    sections.push(`**Strategy Performance:**
+${strategyLines.join(`
+`)}`);
+  }
+  if (bundle.files && bundle.files.length > 0) {
+    const fileLines = bundle.files.slice(0, 5).map((f) => {
+      const gotchaStr = f.gotchas.length > 0 ? ` - ${f.gotchas[0]}` : "";
+      return `- ${f.file}: ${f.failureCount} past failures${gotchaStr}`;
+    });
+    sections.push(`**File-Specific Gotchas:**
+${fileLines.join(`
+`)}`);
+  }
+  if (bundle.patterns && bundle.patterns.length > 0) {
+    const patternLines = bundle.patterns.slice(0, 3).map((p) => `- ${p.pattern} (${p.frequency}x): ${p.recommendation}`);
+    sections.push(`**Common Pitfalls:**
+${patternLines.join(`
+`)}`);
+  }
+  if (sections.length === 0) {
+    return "";
+  }
+  let result = sections.join(`
+
+`);
+  const maxChars = maxTokens * 4;
+  if (result.length > maxChars) {
+    result = result.slice(0, maxChars - 3) + "...";
+  }
+  return result;
+}
+async function getCachedInsights(_swarmMail, cacheKey, computeFn) {
+  const cached5 = insightsCache.get(cacheKey);
+  if (cached5 && cached5.expires > Date.now()) {
+    return cached5.data;
+  }
+  const data = await computeFn();
+  insightsCache.set(cacheKey, {
+    data,
+    expires: Date.now() + CACHE_TTL_MS
+  });
+  return data;
+}
+function clearInsightsCache() {
+  insightsCache.clear();
+}
+var insightsCache, CACHE_TTL_MS;
+var init_swarm_insights = __esm(() => {
+  insightsCache = new Map;
+  CACHE_TTL_MS = 5 * 60 * 1000;
+});
+
 // src/model-selection.ts
 var exports_model_selection = {};
 __export(exports_model_selection, {
@@ -91404,6 +91576,7 @@ var CellQueryArgsSchema = exports_external.object({
   status: CellStatusSchema.optional(),
   type: CellTypeSchema.optional(),
   ready: exports_external.boolean().optional(),
+  parent_id: exports_external.string().optional(),
   limit: exports_external.number().int().positive().default(20)
 });
 var SubtaskSpecSchema = exports_external.object({
@@ -92449,6 +92622,7 @@ var hive_query = tool({
     status: tool.schema.enum(["open", "in_progress", "blocked", "closed"]).optional().describe("Filter by status"),
     type: tool.schema.enum(["bug", "feature", "task", "epic", "chore"]).optional().describe("Filter by type"),
     ready: tool.schema.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().describe("Max results to return (default: 20)")
   },
   async execute(args, ctx) {
@@ -92464,6 +92638,7 @@ var hive_query = tool({
         cells = await adapter.queryCells(projectKey, {
           status: validated.status,
           type: validated.type,
+          parent_id: validated.parent_id,
           limit: validated.limit || 20
         });
       }
@@ -92600,6 +92775,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
@@ -92613,6 +92789,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)")
   },
@@ -92640,6 +92817,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
       });
       const formatted = cells.map((c) => formatCellForOutput(c));
@@ -114092,38 +114270,28 @@ async function getPromptInsights(options2) {
 }
 async function getCoordinatorInsights(project_key) {
   try {
-    const { createLibSQLAdapter, createSwarmMailAdapter: createSwarmMailAdapter2, strategySuccessRates } = await import("swarm-mail");
+    const { createLibSQLAdapter, createSwarmMailAdapter: createSwarmMailAdapter2 } = await import("swarm-mail");
+    const { getStrategyInsights: getStrategyInsights2, getPatternInsights: getPatternInsights2, formatInsightsForPrompt: formatInsightsForPrompt2 } = await Promise.resolve().then(() => (init_swarm_insights(), exports_swarm_insights));
     const dbAdapter = await createLibSQLAdapter({ url: "file:./.swarm-mail/streams.db" });
     const adapter = createSwarmMailAdapter2(dbAdapter, project_key || "default");
-    const db = await adapter.getDatabase();
-    const query = strategySuccessRates({ project_key });
-    const result = await db.query(query.sql, Object.values(query.parameters || {}));
-    if (!result || !result.rows || result.rows.length === 0) {
+    const [strategies, patterns] = await Promise.all([
+      getStrategyInsights2(adapter, ""),
+      getPatternInsights2(adapter)
+    ]);
+    const bundle = {
+      strategies,
+      patterns
+    };
+    const formatted = formatInsightsForPrompt2(bundle, { maxTokens: 500 });
+    if (!formatted) {
       return "";
     }
-    const rows = result.rows.map((r) => {
-      const strategy = r.strategy || "unknown";
-      const total = r.total_attempts || 0;
-      const successRate = r.success_rate || 0;
-      const emoji3 = successRate >= 80 ? "✅" : successRate >= 60 ? "⚠️" : "❌";
-      return `| ${emoji3} ${strategy} | ${successRate.toFixed(1)}% | ${total} |`;
-    });
-    const topRows = rows.slice(0, 5);
-    const antiPatterns = result.rows.filter((r) => r.success_rate < 60).map((r) => `- AVOID: ${r.strategy} strategy (${r.success_rate.toFixed(1)}% success rate)`).slice(0, 3);
-    const antiPatternsSection = antiPatterns.length > 0 ? `
-
-**Anti-Patterns:**
-${antiPatterns.join(`
-`)}` : "";
     return `
-## \uD83D\uDCCA Swarm Insights (Strategy Success Rates)
+## \uD83D\uDCCA Historical Insights
 
-| Strategy | Success Rate | Total Attempts |
-|----------|--------------|----------------|
-${topRows.join(`
-`)}
+${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);
@@ -114132,7 +114300,9 @@ ${topRows.join(`
 }
 async function getWorkerInsights(files, domain2) {
   try {
-    const adapter = await getMemoryAdapter();
+    const { createLibSQLAdapter, createSwarmMailAdapter: createSwarmMailAdapter2 } = await import("swarm-mail");
+    const { getFileInsights: getFileInsights2, formatInsightsForPrompt: formatInsightsForPrompt2 } = await Promise.resolve().then(() => (init_swarm_insights(), exports_swarm_insights));
+    const memoryAdapter = await getMemoryAdapter();
     let query = "";
     if (files && files.length > 0) {
       const keywords = files.flatMap((f) => f.split(/[\/\\.]/).filter((part) => part.length > 2)).slice(0, 5);
@@ -114142,25 +114312,48 @@ async function getWorkerInsights(files, domain2) {
     } else {
       return "";
     }
-    const result = await adapter.find({
-      query: `${query} gotcha pitfall pattern bug`,
-      limit: 3
-    });
-    if (result.count === 0) {
-      return "";
-    }
-    const learnings = result.results.map((r) => {
-      const content = r.content.length > 150 ? r.content.slice(0, 150) + "..." : r.content;
-      return `- ${content}`;
-    });
-    return `
-## \uD83D\uDCA1 Relevant Learnings (from past agents)
+    const [fileInsights, memoryResult] = await Promise.all([
+      (async () => {
+        if (!files || files.length === 0)
+          return [];
+        try {
+          const dbAdapter = await createLibSQLAdapter({ url: "file:./.swarm-mail/streams.db" });
+          const swarmMail = createSwarmMailAdapter2(dbAdapter, "default");
+          return await getFileInsights2(swarmMail, files);
+        } catch (e) {
+          console.warn("Failed to get file insights from event store:", e);
+          return [];
+        }
+      })(),
+      memoryAdapter.find({
+        query: `${query} gotcha pitfall pattern bug`,
+        limit: 3
+      })
+    ]);
+    const bundle = {
+      files: fileInsights
+    };
+    const formattedFileInsights = formatInsightsForPrompt2(bundle, { maxTokens: 300 });
+    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 = `## \uD83D\uDCA1 Relevant Learnings (from past agents)
 
 ${learnings.join(`
 `)}
 
-**Check semantic-memory for full details if needed.**
-`;
+**Check semantic-memory for full details if needed.**`;
+    }
+    const sections = [formattedFileInsights, formattedMemory].filter((s) => s.length > 0);
+    if (sections.length === 0) {
+      return "";
+    }
+    return sections.join(`
+
+`);
   } catch (e) {
     console.warn("Failed to get worker insights:", e);
     return "";
@@ -121254,7 +121447,8 @@ var allTools = {
   ...repoCrawlTools,
   ...skillsTools,
   ...mandateTools,
-  ...memoryTools
+  ...memoryTools,
+  ...observabilityTools
 };
 export {
   withToolFallback,