opencode-swarm-plugin 0.12.11 → 0.12.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.12.11",
+  "version": "0.12.14",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     }
   },
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target bun && bun build ./src/plugin.ts --outfile ./dist/plugin.js --target bun",
+    "build": "bun build ./src/index.ts --outdir ./dist --target node && bun build ./src/plugin.ts --outfile ./dist/plugin.js --target node",
     "dev": "bun --watch src/index.ts",
     "test": "bun test src/schemas/",
     "test:watch": "bun test --watch",

package/src/learning.ts

@@ -231,11 +231,14 @@ export function calculateDecayedValue(
   now: Date = new Date(),
   halfLifeDays: number = 90,
 ): number {
+  // Prevent division by zero
+  const safeHalfLife = halfLifeDays <= 0 ? 1 : halfLifeDays;
+
   const eventTime = new Date(timestamp).getTime();
   const nowTime = now.getTime();
   const ageDays = Math.max(0, (nowTime - eventTime) / (24 * 60 * 60 * 1000));
 
-  return Math.pow(0.5, ageDays / halfLifeDays);
+  return Math.pow(0.5, ageDays / safeHalfLife);
 }
 
 /**
@@ -252,6 +255,18 @@ export function calculateCriterionWeight(
   events: FeedbackEvent[],
   config: LearningConfig = DEFAULT_LEARNING_CONFIG,
 ): CriterionWeight {
+  // Return early with default weight if events array is empty
+  if (events.length === 0) {
+    return {
+      criterion: "unknown",
+      weight: 1.0,
+      helpful_count: 0,
+      harmful_count: 0,
+      last_validated: undefined,
+      half_life_days: config.halfLifeDays,
+    };
+  }
+
   const now = new Date();
   let helpfulSum = 0;
   let harmfulSum = 0;
@@ -284,7 +299,7 @@ export function calculateCriterionWeight(
   const weight = total > 0 ? Math.max(0.1, helpfulSum / total) : 1.0;
 
   return {
-    criterion: events[0]?.criterion ?? "unknown",
+    criterion: events[0].criterion,
     weight,
     helpful_count: helpfulCount,
     harmful_count: harmfulCount,
@@ -476,12 +491,24 @@ export interface FeedbackStorage {
 
 /**
  * In-memory feedback storage (for testing and short-lived sessions)
+ *
+ * Uses LRU eviction to prevent unbounded memory growth.
  */
 export class InMemoryFeedbackStorage implements FeedbackStorage {
   private events: FeedbackEvent[] = [];
+  private readonly maxSize: number;
+
+  constructor(maxSize: number = 10000) {
+    this.maxSize = maxSize;
+  }
 
   async store(event: FeedbackEvent): Promise<void> {
     this.events.push(event);
+
+    // Evict oldest events if we exceed max size (LRU)
+    if (this.events.length > this.maxSize) {
+      this.events = this.events.slice(this.events.length - this.maxSize);
+    }
   }
 
   async getByCriterion(criterion: string): Promise<FeedbackEvent[]> {

package/src/rate-limiter.ts

@@ -28,11 +28,40 @@
  */
 
 import Redis from "ioredis";
-import { Database } from "bun:sqlite";
 import { mkdirSync, existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 
+// SQLite is optional - only available in Bun runtime
+// We use dynamic import to avoid breaking Node.js environments
+interface BunDatabase {
+  run(sql: string, params?: unknown[]): void;
+  query<T>(sql: string): {
+    get(...params: unknown[]): T | null;
+  };
+  prepare(sql: string): {
+    run(...params: unknown[]): void;
+  };
+  close(): void;
+}
+
+let sqliteAvailable = false;
+let createDatabase: ((path: string) => BunDatabase) | null = null;
+
+// Try to load bun:sqlite at module load time
+try {
+  if (typeof globalThis.Bun !== "undefined") {
+    // We're in Bun runtime - dynamic import will work
+    const bunSqlite = await import("bun:sqlite");
+    createDatabase = (path: string) =>
+      new bunSqlite.Database(path) as unknown as BunDatabase;
+    sqliteAvailable = true;
+  }
+} catch {
+  // Not in Bun runtime, SQLite fallback unavailable
+  sqliteAvailable = false;
+}
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -290,16 +319,20 @@ export class RedisRateLimiter implements RateLimiter {
  * Uses sliding window via COUNT query with timestamp filter.
  */
 export class SqliteRateLimiter implements RateLimiter {
-  private db: Database;
+  private db: BunDatabase;
 
   constructor(dbPath: string) {
+    if (!sqliteAvailable || !createDatabase) {
+      throw new Error("SQLite is not available in this runtime (requires Bun)");
+    }
+
     // Ensure directory exists
     const dir = dirname(dbPath);
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true });
     }
 
-    this.db = new Database(dbPath);
+    this.db = createDatabase(dbPath);
     this.initialize();
   }
 
@@ -381,13 +414,23 @@ export class SqliteRateLimiter implements RateLimiter {
 
     // Count requests in window
     const result = this.db
-      .query<{ count: number }, [string, string, string, number]>(
+      .query<{ count: number }>(
         `SELECT COUNT(*) as count FROM rate_limits 
          WHERE agent_name = ? AND endpoint = ? AND window = ? AND timestamp > ?`,
       )
       .get(agentName, endpoint, window, windowStart);
 
-    const count = result?.count || 0;
+    // Validate result before accessing properties
+    if (!result || typeof result.count !== "number") {
+      // Query failed or returned invalid data, assume no usage
+      return {
+        allowed: true,
+        remaining: limit,
+        resetAt: now + windowDuration,
+      };
+    }
+
+    const count = result.count;
     const remaining = Math.max(0, limit - count);
     const allowed = count < limit;
 
@@ -395,13 +438,14 @@ export class SqliteRateLimiter implements RateLimiter {
     let resetAt = now + windowDuration;
     if (!allowed) {
       const oldest = this.db
-        .query<{ timestamp: number }, [string, string, string, number]>(
+        .query<{ timestamp: number }>(
           `SELECT MIN(timestamp) as timestamp FROM rate_limits 
            WHERE agent_name = ? AND endpoint = ? AND window = ? AND timestamp > ?`,
         )
         .get(agentName, endpoint, window, windowStart);
 
-      if (oldest?.timestamp) {
+      // Validate oldest result before accessing properties
+      if (oldest && typeof oldest.timestamp === "number") {
         resetAt = oldest.timestamp + windowDuration;
       }
     }
@@ -582,6 +626,11 @@ export async function createRateLimiter(options?: {
   }
 
   if (backend === "sqlite") {
+    if (!sqliteAvailable) {
+      throw new Error(
+        "SQLite backend requested but not available (requires Bun runtime)",
+      );
+    }
     return new SqliteRateLimiter(sqlitePath);
   }
 
@@ -590,31 +639,55 @@ export async function createRateLimiter(options?: {
     return new RedisRateLimiter(redis);
   }
 
-  // Auto-select: try Redis first, fall back to SQLite
-  try {
-    const redis = new Redis(redisUrl, {
-      connectTimeout: 2000,
-      maxRetriesPerRequest: 1,
-      retryStrategy: () => null, // Don't retry on failure
-      lazyConnect: true,
-    });
-
-    // Test connection
-    await redis.connect();
-    await redis.ping();
+  // Auto-select: try Redis first with retry, fall back to SQLite
+  const maxRetries = 3;
+  const retryDelays = [100, 500, 1000]; // exponential backoff
+
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      const redis = new Redis(redisUrl, {
+        connectTimeout: 2000,
+        maxRetriesPerRequest: 1,
+        retryStrategy: () => null, // Don't retry on failure
+        lazyConnect: true,
+      });
+
+      // Test connection
+      await redis.connect();
+      await redis.ping();
+
+      return new RedisRateLimiter(redis);
+    } catch (error) {
+      const isLastAttempt = attempt === maxRetries - 1;
+
+      if (isLastAttempt) {
+        // All retries exhausted, fall back to SQLite or in-memory
+        if (!hasWarnedAboutFallback) {
+          const fallbackType = sqliteAvailable ? "SQLite" : "in-memory";
+          const fallbackLocation = sqliteAvailable ? ` at ${sqlitePath}` : "";
+          console.warn(
+            `[rate-limiter] Redis connection failed after ${maxRetries} attempts (${redisUrl}), falling back to ${fallbackType}${fallbackLocation}`,
+          );
+          hasWarnedAboutFallback = true;
+        }
+
+        // Use SQLite if available, otherwise fall back to in-memory
+        if (sqliteAvailable) {
+          return new SqliteRateLimiter(sqlitePath);
+        }
+        return new InMemoryRateLimiter();
+      }
 
-    return new RedisRateLimiter(redis);
-  } catch (error) {
-    // Redis connection failed, fall back to SQLite
-    if (!hasWarnedAboutFallback) {
-      console.warn(
-        `[rate-limiter] Redis connection failed (${redisUrl}), falling back to SQLite at ${sqlitePath}`,
-      );
-      hasWarnedAboutFallback = true;
+      // Wait before retrying (exponential backoff)
+      await new Promise((resolve) => setTimeout(resolve, retryDelays[attempt]));
     }
+  }
 
+  // Fallback (should never reach here due to return in last attempt)
+  if (sqliteAvailable) {
     return new SqliteRateLimiter(sqlitePath);
   }
+  return new InMemoryRateLimiter();
 }
 
 /**

package/src/swarm.ts

@@ -901,9 +901,10 @@ async function queryEpicSubtasks(epicId: string): Promise<Bead[]> {
     .nothrow();
 
   if (result.exitCode !== 0) {
-    // Don't throw - just return empty and warn
-    console.warn(
-      `[swarm] Failed to query subtasks: ${result.stderr.toString()}`,
+    // Don't throw - just return empty and log error prominently
+    console.error(
+      `[swarm] ERROR: Failed to query subtasks for epic ${epicId}:`,
+      result.stderr.toString(),
     );
     return [];
   }
@@ -913,9 +914,16 @@ async function queryEpicSubtasks(epicId: string): Promise<Bead[]> {
     return z.array(BeadSchema).parse(parsed);
   } catch (error) {
     if (error instanceof z.ZodError) {
-      console.warn(`[swarm] Invalid bead data: ${error.message}`);
+      console.error(
+        `[swarm] ERROR: Invalid bead data for epic ${epicId}:`,
+        error.message,
+      );
       return [];
     }
+    console.error(
+      `[swarm] ERROR: Failed to parse beads for epic ${epicId}:`,
+      error,
+    );
     throw error;
   }
 }
@@ -944,8 +952,12 @@ async function querySwarmMessages(
       llm_mode: false, // Just need the count
     });
     return summary.summary.total_messages;
-  } catch {
-    // Thread might not exist yet
+  } catch (error) {
+    // Thread might not exist yet, or query failed
+    console.warn(
+      `[swarm] Failed to query swarm messages for thread ${threadId}:`,
+      error,
+    );
     return 0;
   }
 }
@@ -989,22 +1001,31 @@ interface CassSearchResult {
   }>;
 }
 
+/**
+ * CASS query result with status
+ */
+type CassQueryResult =
+  | { status: "unavailable" }
+  | { status: "failed"; error?: string }
+  | { status: "empty"; query: string }
+  | { status: "success"; data: CassSearchResult };
+
 /**
  * Query CASS for similar past tasks
  *
  * @param task - Task description to search for
  * @param limit - Maximum results to return
- * @returns Search results or null if CASS unavailable
+ * @returns Structured result with status indicator
  */
 async function queryCassHistory(
   task: string,
   limit: number = 3,
-): Promise<CassSearchResult | null> {
+): Promise<CassQueryResult> {
   // Check if CASS is available first
   const cassAvailable = await isToolAvailable("cass");
   if (!cassAvailable) {
     warnMissingTool("cass");
-    return null;
+    return { status: "unavailable" };
   }
 
   try {
@@ -1013,25 +1034,38 @@ async function queryCassHistory(
       .nothrow();
 
     if (result.exitCode !== 0) {
-      return null;
+      const error = result.stderr.toString();
+      console.warn(
+        `[swarm] CASS search failed (exit ${result.exitCode}):`,
+        error,
+      );
+      return { status: "failed", error };
     }
 
     const output = result.stdout.toString();
     if (!output.trim()) {
-      return { query: task, results: [] };
+      return { status: "empty", query: task };
     }
 
     try {
       const parsed = JSON.parse(output);
-      return {
+      const searchResult: CassSearchResult = {
         query: task,
         results: Array.isArray(parsed) ? parsed : parsed.results || [],
       };
-    } catch {
-      return { query: task, results: [] };
+
+      if (searchResult.results.length === 0) {
+        return { status: "empty", query: task };
+      }
+
+      return { status: "success", data: searchResult };
+    } catch (error) {
+      console.warn(`[swarm] Failed to parse CASS output:`, error);
+      return { status: "failed", error: String(error) };
     }
-  } catch {
-    return null;
+  } catch (error) {
+    console.error(`[swarm] CASS query error:`, error);
+    return { status: "failed", error: String(error) };
   }
 }
 
@@ -1223,13 +1257,35 @@ export const swarm_plan_prompt = tool({
 
     // Query CASS for similar past tasks
     let cassContext = "";
-    let cassResult: CassSearchResult | null = null;
+    let cassResultInfo: {
+      queried: boolean;
+      results_found?: number;
+      included_in_context?: boolean;
+      reason?: string;
+    };
 
     if (args.query_cass !== false) {
-      cassResult = await queryCassHistory(args.task, args.cass_limit ?? 3);
-      if (cassResult && cassResult.results.length > 0) {
-        cassContext = formatCassHistoryForPrompt(cassResult);
+      const cassResult = await queryCassHistory(
+        args.task,
+        args.cass_limit ?? 3,
+      );
+      if (cassResult.status === "success") {
+        cassContext = formatCassHistoryForPrompt(cassResult.data);
+        cassResultInfo = {
+          queried: true,
+          results_found: cassResult.data.results.length,
+          included_in_context: true,
+        };
+      } else {
+        cassResultInfo = {
+          queried: true,
+          results_found: 0,
+          included_in_context: false,
+          reason: cassResult.status,
+        };
       }
+    } else {
+      cassResultInfo = { queried: false, reason: "disabled" };
     }
 
     // Format strategy guidelines
@@ -1271,13 +1327,7 @@ export const swarm_plan_prompt = tool({
         },
         validation_note:
           "Parse agent response as JSON and validate with swarm_validate_decomposition",
-        cass_history: cassResult
-          ? {
-              queried: true,
-              results_found: cassResult.results.length,
-              included_in_context: cassResult.results.length > 0,
-            }
-          : { queried: false, reason: "disabled or unavailable" },
+        cass_history: cassResultInfo,
       },
       null,
       2,
@@ -1324,13 +1374,35 @@ export const swarm_decompose = tool({
   async execute(args) {
     // Query CASS for similar past tasks
     let cassContext = "";
-    let cassResult: CassSearchResult | null = null;
+    let cassResultInfo: {
+      queried: boolean;
+      results_found?: number;
+      included_in_context?: boolean;
+      reason?: string;
+    };
 
     if (args.query_cass !== false) {
-      cassResult = await queryCassHistory(args.task, args.cass_limit ?? 3);
-      if (cassResult && cassResult.results.length > 0) {
-        cassContext = formatCassHistoryForPrompt(cassResult);
+      const cassResult = await queryCassHistory(
+        args.task,
+        args.cass_limit ?? 3,
+      );
+      if (cassResult.status === "success") {
+        cassContext = formatCassHistoryForPrompt(cassResult.data);
+        cassResultInfo = {
+          queried: true,
+          results_found: cassResult.data.results.length,
+          included_in_context: true,
+        };
+      } else {
+        cassResultInfo = {
+          queried: true,
+          results_found: 0,
+          included_in_context: false,
+          reason: cassResult.status,
+        };
       }
+    } else {
+      cassResultInfo = { queried: false, reason: "disabled" };
     }
 
     // Combine user context with CASS history
@@ -1363,13 +1435,7 @@ export const swarm_decompose = tool({
         },
         validation_note:
           "Parse agent response as JSON and validate with BeadTreeSchema from schemas/bead.ts",
-        cass_history: cassResult
-          ? {
-              queried: true,
-              results_found: cassResult.results.length,
-              included_in_context: cassResult.results.length > 0,
-            }
-          : { queried: false, reason: "disabled or unavailable" },
+        cass_history: cassResultInfo,
       },
       null,
       2,
@@ -1726,9 +1792,21 @@ async function runUbsScan(files: string[]): Promise<UbsScanResult | null> {
 
     try {
       const parsed = JSON.parse(output);
+
+      // Basic validation of structure
+      if (typeof parsed !== "object" || parsed === null) {
+        throw new Error("UBS output is not an object");
+      }
+      if (!Array.isArray(parsed.bugs)) {
+        console.warn("[swarm] UBS output missing bugs array, using empty");
+      }
+      if (typeof parsed.summary !== "object" || parsed.summary === null) {
+        console.warn("[swarm] UBS output missing summary object, using empty");
+      }
+
       return {
         exitCode: result.exitCode,
-        bugs: parsed.bugs || [],
+        bugs: Array.isArray(parsed.bugs) ? parsed.bugs : [],
         summary: parsed.summary || {
           total: 0,
           critical: 0,
@@ -1737,8 +1815,13 @@ async function runUbsScan(files: string[]): Promise<UbsScanResult | null> {
           low: 0,
         },
       };
-    } catch {
-      // UBS output wasn't JSON, return basic result
+    } catch (error) {
+      // UBS output wasn't JSON - this is an error condition
+      console.error(
+        `[swarm] CRITICAL: UBS scan failed to parse JSON output:`,
+        error,
+      );
+      console.error(`[swarm] Raw output:`, output);
       return {
         exitCode: result.exitCode,
         bugs: [],
@@ -1937,10 +2020,17 @@ export const swarm_complete = tool({
     }
 
     // Release file reservations for this agent
-    await mcpCall("release_file_reservations", {
-      project_key: args.project_key,
-      agent_name: args.agent_name,
-    });
+    try {
+      await mcpCall("release_file_reservations", {
+        project_key: args.project_key,
+        agent_name: args.agent_name,
+      });
+    } catch (error) {
+      console.warn(
+        `[swarm] Failed to release file reservations for ${args.agent_name}:`,
+        error,
+      );
+    }
 
     // Extract epic ID
     const epicId = args.bead_id.includes(".")