opencode-swarm-plugin 0.1.0 → 0.2.0

package/dist/plugin.js

@@ -12879,6 +12879,216 @@ var beadsTools = {
   beads_link_thread
 };
 
+// src/tool-availability.ts
+var toolCache = new Map;
+var warningsLogged = new Set;
+async function commandExists(cmd) {
+  try {
+    const result = await Bun.$`which ${cmd}`.quiet().nothrow();
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function urlReachable(url2, timeoutMs = 1000) {
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const response = await fetch(url2, {
+      method: "HEAD",
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+var toolCheckers = {
+  "semantic-memory": async () => {
+    const nativeExists = await commandExists("semantic-memory");
+    if (nativeExists) {
+      try {
+        const result = await Bun.$`semantic-memory stats`.quiet().nothrow();
+        return {
+          available: result.exitCode === 0,
+          checkedAt: new Date().toISOString(),
+          version: "native"
+        };
+      } catch (e) {
+        return {
+          available: false,
+          checkedAt: new Date().toISOString(),
+          error: String(e)
+        };
+      }
+    }
+    try {
+      const proc = Bun.spawn(["bunx", "semantic-memory", "stats"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const timeout = setTimeout(() => proc.kill(), 1e4);
+      const exitCode = await proc.exited;
+      clearTimeout(timeout);
+      return {
+        available: exitCode === 0,
+        checkedAt: new Date().toISOString(),
+        version: "bunx"
+      };
+    } catch (e) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: String(e)
+      };
+    }
+  },
+  cass: async () => {
+    const exists = await commandExists("cass");
+    if (!exists) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: "cass command not found"
+      };
+    }
+    try {
+      const result = await Bun.$`cass health`.quiet().nothrow();
+      return {
+        available: result.exitCode === 0,
+        checkedAt: new Date().toISOString()
+      };
+    } catch (e) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: String(e)
+      };
+    }
+  },
+  ubs: async () => {
+    const exists = await commandExists("ubs");
+    if (!exists) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: "ubs command not found"
+      };
+    }
+    try {
+      const result = await Bun.$`ubs doctor`.quiet().nothrow();
+      return {
+        available: result.exitCode === 0,
+        checkedAt: new Date().toISOString()
+      };
+    } catch (e) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: String(e)
+      };
+    }
+  },
+  beads: async () => {
+    const exists = await commandExists("bd");
+    if (!exists) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: "bd command not found"
+      };
+    }
+    try {
+      const result = await Bun.$`bd --version`.quiet().nothrow();
+      return {
+        available: result.exitCode === 0,
+        checkedAt: new Date().toISOString()
+      };
+    } catch (e) {
+      return {
+        available: false,
+        checkedAt: new Date().toISOString(),
+        error: String(e)
+      };
+    }
+  },
+  "agent-mail": async () => {
+    const reachable = await urlReachable("http://127.0.0.1:8765/health/liveness");
+    return {
+      available: reachable,
+      checkedAt: new Date().toISOString(),
+      error: reachable ? undefined : "Agent Mail server not reachable at :8765"
+    };
+  }
+};
+var fallbackBehaviors = {
+  "semantic-memory": "Learning data stored in-memory only (lost on session end)",
+  cass: "Decomposition proceeds without historical context from past sessions",
+  ubs: "Subtask completion skips bug scanning - manual review recommended",
+  beads: "Swarm cannot track issues - task coordination will be less reliable",
+  "agent-mail": "Multi-agent coordination disabled - file conflicts possible if multiple agents active"
+};
+async function checkTool(tool3) {
+  const cached2 = toolCache.get(tool3);
+  if (cached2) {
+    return cached2;
+  }
+  const checker = toolCheckers[tool3];
+  const status = await checker();
+  toolCache.set(tool3, status);
+  return status;
+}
+async function isToolAvailable(tool3) {
+  const status = await checkTool(tool3);
+  return status.available;
+}
+async function getToolAvailability(tool3) {
+  const status = await checkTool(tool3);
+  return {
+    tool: tool3,
+    status,
+    fallbackBehavior: fallbackBehaviors[tool3]
+  };
+}
+async function checkAllTools() {
+  const tools = [
+    "semantic-memory",
+    "cass",
+    "ubs",
+    "beads",
+    "agent-mail"
+  ];
+  const results = new Map;
+  const checks3 = await Promise.all(tools.map(async (tool3) => ({
+    tool: tool3,
+    availability: await getToolAvailability(tool3)
+  })));
+  for (const { tool: tool3, availability } of checks3) {
+    results.set(tool3, availability);
+  }
+  return results;
+}
+function warnMissingTool(tool3) {
+  if (warningsLogged.has(tool3)) {
+    return;
+  }
+  warningsLogged.add(tool3);
+  const fallback = fallbackBehaviors[tool3];
+  console.warn(`[swarm] ${tool3} not available: ${fallback}`);
+}
+function formatToolAvailability(availability) {
+  const lines = ["Tool Availability:"];
+  for (const [tool3, info] of availability) {
+    const status = info.status.available ? "\u2713" : "\u2717";
+    const version2 = info.status.version ? ` (${info.status.version})` : "";
+    const fallback = info.status.available ? "" : ` \u2192 ${info.fallbackBehavior}`;
+    lines.push(`  ${status} ${tool3}${version2}${fallback}`);
+  }
+  return lines.join(`
+`);
+}
+
 // src/agent-mail.ts
 var AGENT_MAIL_URL = "http://127.0.0.1:8765";
 var DEFAULT_TTL_SECONDS = 3600;
@@ -12913,6 +13123,14 @@ class FileReservationConflictError extends Error {
     this.name = "FileReservationConflictError";
   }
 }
+var agentMailAvailable = null;
+async function checkAgentMailAvailable() {
+  if (agentMailAvailable !== null) {
+    return agentMailAvailable;
+  }
+  agentMailAvailable = await isToolAvailable("agent-mail");
+  return agentMailAvailable;
+}
 async function mcpCall(toolName, args) {
   const response = await fetch(`${AGENT_MAIL_URL}/mcp/`, {
     method: "POST",
@@ -12962,6 +13180,16 @@ var agentmail_init = tool({
     task_description: tool.schema.string().optional().describe("Description of current task")
   },
   async execute(args, ctx) {
+    const available = await checkAgentMailAvailable();
+    if (!available) {
+      warnMissingTool("agent-mail");
+      return JSON.stringify({
+        error: "Agent Mail server not available",
+        available: false,
+        hint: "Start Agent Mail with: agent-mail serve",
+        fallback: "Swarm will continue without multi-agent coordination. File conflicts possible if multiple agents active."
+      }, null, 2);
+    }
     const project = await mcpCall("ensure_project", {
       human_key: args.project_path
     });
@@ -12979,7 +13207,7 @@ var agentmail_init = tool({
       startedAt: new Date().toISOString()
     };
     setState(ctx.sessionID, state);
-    return JSON.stringify({ project, agent }, null, 2);
+    return JSON.stringify({ project, agent, available: true }, null, 2);
   }
 });
 var agentmail_send = tool({
@@ -13762,6 +13990,18 @@ var DECOMPOSITION_PROMPT = `You are decomposing a task into parallelizable subta
 
 {context_section}
 
+## MANDATORY: Beads Issue Tracking
+
+**Every subtask MUST become a bead.** This is non-negotiable.
+
+After decomposition, the coordinator will:
+1. Create an epic bead for the overall task
+2. Create child beads for each subtask
+3. Track progress through bead status updates
+4. Close beads with summaries when complete
+
+Agents MUST update their bead status as they work. No silent progress.
+
 ## Requirements
 
 1. **Break into 2-{max_subtasks} independent subtasks** that can run in parallel
@@ -13769,6 +14009,7 @@ var DECOMPOSITION_PROMPT = `You are decomposing a task into parallelizable subta
 3. **No file overlap** - files cannot appear in multiple subtasks (they get exclusive locks)
 4. **Order by dependency** - if subtask B needs subtask A's output, A must come first in the array
 5. **Estimate complexity** - 1 (trivial) to 5 (complex)
+6. **Plan aggressively** - break down more than you think necessary, smaller is better
 
 ## Response Format
 
@@ -13795,10 +14036,12 @@ Respond with a JSON object matching this schema:
 
 ## Guidelines
 
+- **Plan aggressively** - when in doubt, split further. 3 small tasks > 1 medium task
 - **Prefer smaller, focused subtasks** over large complex ones
 - **Include test files** in the same subtask as the code they test
 - **Consider shared types** - if multiple files share types, handle that first
 - **Think about imports** - changes to exported APIs affect downstream files
+- **Explicit > implicit** - spell out what each subtask should do, don't assume
 
 ## File Assignment Examples
 
@@ -13829,19 +14072,49 @@ send a message to the coordinator requesting the change.
 ## Shared Context
 {shared_context}
 
+## MANDATORY: Beads Tracking
+
+You MUST keep your bead updated as you work:
+
+1. **Your bead is already in_progress** - don't change this unless blocked
+2. **If blocked**: \`bd update {bead_id} --status blocked\` and message coordinator
+3. **When done**: Use \`swarm_complete\` - it closes your bead automatically
+4. **Discovered issues**: Create new beads with \`bd create "issue" -t bug\`
+
+**Never work silently.** Your bead status is how the swarm tracks progress.
+
+## MANDATORY: Agent Mail Communication
+
+You MUST communicate with other agents:
+
+1. **Report progress** every significant milestone (not just at the end)
+2. **Ask questions** if requirements are unclear - don't guess
+3. **Announce blockers** immediately - don't spin trying to fix alone
+4. **Coordinate on shared concerns** - if you see something affecting other agents, say so
+
+Use Agent Mail for all communication:
+\`\`\`
+agentmail_send(
+  to: ["coordinator" or specific agent],
+  subject: "Brief subject",
+  body: "Message content",
+  thread_id: "{epic_id}"
+)
+\`\`\`
+
 ## Coordination Protocol
 
 1. **Start**: Your bead is already marked in_progress
-2. **Progress**: Use swarm:progress to report status updates
-3. **Blocked**: If you hit a blocker, report it - don't spin
-4. **Complete**: Use swarm:complete when done - it handles:
+2. **Progress**: Use swarm_progress to report status updates
+3. **Blocked**: Report immediately via Agent Mail - don't spin
+4. **Complete**: Use swarm_complete when done - it handles:
    - Closing your bead with a summary
    - Releasing file reservations
    - Notifying the coordinator
 
 ## Self-Evaluation
 
-Before calling swarm:complete, evaluate your work:
+Before calling swarm_complete, evaluate your work:
 - Type safety: Does it compile without errors?
 - No obvious bugs: Did you handle edge cases?
 - Follows patterns: Does it match existing code style?
@@ -13849,17 +14122,13 @@ Before calling swarm:complete, evaluate your work:
 
 If evaluation fails, fix the issues before completing.
 
-## Communication
+## Planning Your Work
 
-To message other agents or the coordinator:
-\`\`\`
-agent-mail:send(
-  to: ["coordinator_name" or other agent],
-  subject: "Brief subject",
-  body: "Message content",
-  thread_id: "{epic_id}"
-)
-\`\`\`
+Before writing code:
+1. **Read the files** you're assigned to understand current state
+2. **Plan your approach** - what changes, in what order?
+3. **Identify risks** - what could go wrong? What dependencies?
+4. **Communicate your plan** via Agent Mail if non-trivial
 
 Begin work on your subtask now.`;
 var EVALUATION_PROMPT = `Evaluate the work completed for this subtask.
@@ -13926,21 +14195,32 @@ function formatEvaluationPrompt(params) {
   return EVALUATION_PROMPT.replace("{bead_id}", params.bead_id).replace("{subtask_title}", params.subtask_title).replace("{files_touched}", filesList || "(no files recorded)");
 }
 async function queryEpicSubtasks(epicId) {
+  const beadsAvailable = await isToolAvailable("beads");
+  if (!beadsAvailable) {
+    warnMissingTool("beads");
+    return [];
+  }
   const result = await Bun.$`bd list --parent ${epicId} --json`.quiet().nothrow();
   if (result.exitCode !== 0) {
-    throw new SwarmError(`Failed to query subtasks: ${result.stderr.toString()}`, "query_subtasks");
+    console.warn(`[swarm] Failed to query subtasks: ${result.stderr.toString()}`);
+    return [];
   }
   try {
     const parsed = JSON.parse(result.stdout.toString());
     return exports_external.array(BeadSchema).parse(parsed);
   } catch (error45) {
     if (error45 instanceof exports_external.ZodError) {
-      throw new SwarmError(`Invalid bead data: ${error45.message}`, "query_subtasks", error45.issues);
+      console.warn(`[swarm] Invalid bead data: ${error45.message}`);
+      return [];
     }
     throw error45;
   }
 }
 async function querySwarmMessages(projectKey, threadId) {
+  const agentMailAvailable2 = await isToolAvailable("agent-mail");
+  if (!agentMailAvailable2) {
+    return 0;
+  }
   try {
     const summary = await mcpCall("summarize_thread", {
       project_key: projectKey,
@@ -13969,11 +14249,13 @@ ${progress.blockers.map((b) => `- ${b}`).join(`
 `);
 }
 async function queryCassHistory(task, limit = 3) {
+  const cassAvailable = await isToolAvailable("cass");
+  if (!cassAvailable) {
+    warnMissingTool("cass");
+    return null;
+  }
   try {
     const result = await Bun.$`cass search ${task} --limit ${limit} --json`.quiet().nothrow();
-    if (result.exitCode === 127) {
-      return null;
-    }
     if (result.exitCode !== 0) {
       return null;
     }
@@ -14233,11 +14515,13 @@ async function runUbsScan(files) {
   if (files.length === 0) {
     return null;
   }
+  const ubsAvailable = await isToolAvailable("ubs");
+  if (!ubsAvailable) {
+    warnMissingTool("ubs");
+    return null;
+  }
   try {
     const result = await Bun.$`ubs scan ${files.join(" ")} --json`.quiet().nothrow();
-    if (result.exitCode === 127) {
-      return null;
-    }
     const output = result.stdout.toString();
     if (!output.trim()) {
       return {
@@ -14468,7 +14752,56 @@ var swarm_evaluation_prompt = tool({
     }, null, 2);
   }
 });
+var swarm_init = tool({
+  description: "Initialize swarm session and check tool availability. Call at swarm start to see what features are available.",
+  args: {
+    project_path: tool.schema.string().optional().describe("Project path (for Agent Mail init)")
+  },
+  async execute(args) {
+    const availability = await checkAllTools();
+    const report = formatToolAvailability(availability);
+    const beadsAvailable = availability.get("beads")?.status.available ?? false;
+    const agentMailAvailable2 = availability.get("agent-mail")?.status.available ?? false;
+    const warnings = [];
+    const degradedFeatures = [];
+    if (!beadsAvailable) {
+      warnings.push("\u26A0\uFE0F  beads (bd) not available - issue tracking disabled, swarm coordination will be limited");
+      degradedFeatures.push("issue tracking", "progress persistence");
+    }
+    if (!agentMailAvailable2) {
+      warnings.push("\u26A0\uFE0F  agent-mail not available - multi-agent communication disabled");
+      degradedFeatures.push("agent communication", "file reservations");
+    }
+    if (!availability.get("cass")?.status.available) {
+      degradedFeatures.push("historical context from past sessions");
+    }
+    if (!availability.get("ubs")?.status.available) {
+      degradedFeatures.push("pre-completion bug scanning");
+    }
+    if (!availability.get("semantic-memory")?.status.available) {
+      degradedFeatures.push("persistent learning (using in-memory fallback)");
+    }
+    return JSON.stringify({
+      ready: true,
+      tool_availability: Object.fromEntries(Array.from(availability.entries()).map(([k, v]) => [
+        k,
+        {
+          available: v.status.available,
+          fallback: v.status.available ? null : v.fallbackBehavior
+        }
+      ])),
+      warnings: warnings.length > 0 ? warnings : undefined,
+      degraded_features: degradedFeatures.length > 0 ? degradedFeatures : undefined,
+      recommendations: {
+        beads: beadsAvailable ? "\u2713 Use beads for all task tracking" : "Install beads: npm i -g @joelhooks/beads",
+        agent_mail: agentMailAvailable2 ? "\u2713 Use Agent Mail for coordination" : "Start Agent Mail: agent-mail serve"
+      },
+      report
+    }, null, 2);
+  }
+});
 var swarmTools = {
+  swarm_init,
   swarm_decompose,
   swarm_validate_decomposition,
   swarm_status,
@@ -14478,6 +14811,93 @@ var swarmTools = {
   swarm_subtask_prompt,
   swarm_evaluation_prompt
 };
+// src/anti-patterns.ts
+var PatternKindSchema = exports_external.enum(["pattern", "anti_pattern"]);
+var DecompositionPatternSchema = exports_external.object({
+  id: exports_external.string(),
+  content: exports_external.string(),
+  kind: PatternKindSchema,
+  is_negative: exports_external.boolean(),
+  success_count: exports_external.number().int().min(0).default(0),
+  failure_count: exports_external.number().int().min(0).default(0),
+  created_at: exports_external.string(),
+  updated_at: exports_external.string(),
+  reason: exports_external.string().optional(),
+  tags: exports_external.array(exports_external.string()).default([]),
+  example_beads: exports_external.array(exports_external.string()).default([])
+});
+var PatternInversionResultSchema = exports_external.object({
+  original: DecompositionPatternSchema,
+  inverted: DecompositionPatternSchema,
+  reason: exports_external.string()
+});
+class InMemoryPatternStorage {
+  patterns = new Map;
+  async store(pattern) {
+    this.patterns.set(pattern.id, pattern);
+  }
+  async get(id) {
+    return this.patterns.get(id) ?? null;
+  }
+  async getAll() {
+    return Array.from(this.patterns.values());
+  }
+  async getAntiPatterns() {
+    return Array.from(this.patterns.values()).filter((p) => p.kind === "anti_pattern");
+  }
+  async getByTag(tag) {
+    return Array.from(this.patterns.values()).filter((p) => p.tags.includes(tag));
+  }
+  async findByContent(content) {
+    const lower = content.toLowerCase();
+    return Array.from(this.patterns.values()).filter((p) => p.content.toLowerCase().includes(lower));
+  }
+}
+
+// src/pattern-maturity.ts
+var MaturityStateSchema = exports_external.enum([
+  "candidate",
+  "established",
+  "proven",
+  "deprecated"
+]);
+var PatternMaturitySchema = exports_external.object({
+  pattern_id: exports_external.string(),
+  state: MaturityStateSchema,
+  helpful_count: exports_external.number().int().min(0),
+  harmful_count: exports_external.number().int().min(0),
+  last_validated: exports_external.string(),
+  promoted_at: exports_external.string().optional(),
+  deprecated_at: exports_external.string().optional()
+});
+var MaturityFeedbackSchema = exports_external.object({
+  pattern_id: exports_external.string(),
+  type: exports_external.enum(["helpful", "harmful"]),
+  timestamp: exports_external.string(),
+  weight: exports_external.number().min(0).max(1).default(1)
+});
+class InMemoryMaturityStorage {
+  maturities = new Map;
+  feedback = [];
+  async store(maturity) {
+    this.maturities.set(maturity.pattern_id, maturity);
+  }
+  async get(patternId) {
+    return this.maturities.get(patternId) ?? null;
+  }
+  async getAll() {
+    return Array.from(this.maturities.values());
+  }
+  async getByState(state) {
+    return Array.from(this.maturities.values()).filter((m) => m.state === state);
+  }
+  async storeFeedback(feedback) {
+    this.feedback.push(feedback);
+  }
+  async getFeedback(patternId) {
+    return this.feedback.filter((f) => f.pattern_id === patternId);
+  }
+}
 
 // src/index.ts
 var SwarmPlugin = async (input) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.1.0",
-  "description": "OpenCode plugin for type-safe swarm coordination with Agent Mail integration",
+  "version": "0.2.0",
+  "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -41,7 +41,11 @@
     "swarm",
     "agent-mail",
     "beads",
-    "multi-agent"
+    "multi-agent",
+    "ai-agents",
+    "machine-learning",
+    "task-decomposition",
+    "coordination"
   ],
   "author": "Joel Hooks",
   "license": "MIT",

package/src/agent-mail.ts

@@ -9,9 +9,14 @@
  * - fetch_inbox ALWAYS limits to 5 messages max
  * - Use summarize_thread instead of fetching all messages
  * - Auto-release reservations when tasks complete
+ *
+ * GRACEFUL DEGRADATION:
+ * - If Agent Mail server is not running, tools return helpful error messages
+ * - Swarm can still function without Agent Mail (just no coordination)
  */
 import { tool } from "@opencode-ai/plugin";
 import { z } from "zod";
+import { isToolAvailable, warnMissingTool } from "./tool-availability";
 
 // ============================================================================
 // Configuration
@@ -163,13 +168,35 @@ interface MCPToolResult<T = unknown> {
   isError?: boolean;
 }
 
+/** Cached availability check result */
+let agentMailAvailable: boolean | null = null;
+
+/**
+ * Check if Agent Mail server is available (cached)
+ */
+async function checkAgentMailAvailable(): Promise<boolean> {
+  if (agentMailAvailable !== null) {
+    return agentMailAvailable;
+  }
+
+  agentMailAvailable = await isToolAvailable("agent-mail");
+  return agentMailAvailable;
+}
+
+/**
+ * Reset availability cache (for testing)
+ */
+export function resetAgentMailCache(): void {
+  agentMailAvailable = null;
+}
+
 /**
  * Call an Agent Mail MCP tool
  *
  * Handles both direct results (mock server) and wrapped results (real server).
  * Real Agent Mail returns: { content: [...], structuredContent: {...} }
  */
-async function mcpCall<T>(
+export async function mcpCall<T>(
   toolName: string,
   args: Record<string, unknown>,
 ): Promise<T> {
@@ -281,6 +308,23 @@ export const agentmail_init = tool({
       .describe("Description of current task"),
   },
   async execute(args, ctx) {
+    // Check if Agent Mail is available
+    const available = await checkAgentMailAvailable();
+    if (!available) {
+      warnMissingTool("agent-mail");
+      return JSON.stringify(
+        {
+          error: "Agent Mail server not available",
+          available: false,
+          hint: "Start Agent Mail with: agent-mail serve",
+          fallback:
+            "Swarm will continue without multi-agent coordination. File conflicts possible if multiple agents active.",
+        },
+        null,
+        2,
+      );
+    }
+
     // 1. Ensure project exists
     const project = await mcpCall<ProjectInfo>("ensure_project", {
       human_key: args.project_path,
@@ -304,7 +348,7 @@ export const agentmail_init = tool({
     };
     setState(ctx.sessionID, state);
 
-    return JSON.stringify({ project, agent }, null, 2);
+    return JSON.stringify({ project, agent, available: true }, null, 2);
   },
 });
 
@@ -654,7 +698,6 @@ export const agentMailTools = {
 // ============================================================================
 
 export {
-  mcpCall,
   requireState,
   setState,
   getState,