opencode-swarm-plugin 0.29.0 → 0.30.2

package/.turbo/turbo-build.log

@@ -1,9 +1,9 @@
 $ bun build ./src/index.ts --outdir ./dist --target node --external @electric-sql/pglite --external swarm-mail && bun build ./src/plugin.ts --outfile ./dist/plugin.js --target node --external @electric-sql/pglite --external swarm-mail && tsc
-Bundled 200 modules in 35ms
+Bundled 811 modules in 121ms
 
-  index.js  1.20 MB  (entry point)
+  index.js  1.71 MB  (entry point)
 
-Bundled 201 modules in 34ms
+Bundled 812 modules in 142ms
 
-  plugin.js  1.16 MB  (entry point)
+  plugin.js  1.67 MB  (entry point)
 

package/CHANGELOG.md

@@ -1,5 +1,99 @@
 # opencode-swarm-plugin
 
+## 0.30.2
+
+### Patch Changes
+
+- [`5858148`](https://github.com/joelhooks/swarm-tools/commit/5858148d5785393c0a6993a2595fba275f305707) Thanks [@joelhooks](https://github.com/joelhooks)! - chore: trigger publish workflow
+
+## 0.30.1
+
+### Patch Changes
+
+- [`57d5600`](https://github.com/joelhooks/swarm-tools/commit/57d5600a53e148ce1d1da48b3b5a8723a5552e04) Thanks [@joelhooks](https://github.com/joelhooks)! - ## 🚦 Review Gate UX Fix + Verbose Setup
+
+  > _"A common mistake that people make when trying to design something completely foolproof is to underestimate the ingenuity of complete fools."_
+  > — Douglas Adams, _Mostly Harmless_
+
+  Two UX improvements that make swarm coordination feel less like shouting into the void.
+
+  ### What Changed
+
+  **Review Gate Response Fix:**
+
+  - `swarm_complete` no longer returns `success: false` when code review is pending
+  - Now returns `success: true` with `status: "pending_review"` or `status: "needs_changes"`
+  - **Why it matters**: The old format made review checkpoints look like errors. Agents would retry unnecessarily or report failures when the workflow was actually working as designed. Review gates are a feature, not a bug.
+
+  **Setup Command Verbosity:**
+
+  - Added `p.log.step()` and `p.log.success()` throughout swarm setup
+  - Users can now see exactly what's happening: dependency checks, git init, swarm-mail connection
+  - **Why it matters**: Silent setup commands feel broken. Explicit progress logs build trust and make debugging easier when setup actually does fail.
+
+  ### Why It Matters
+
+  **For Agents:**
+
+  - No more false-negative responses from review gates
+  - Clear workflow state (pending vs. needs changes vs. complete)
+  - Reduced retry loops and error noise
+
+  **For Users:**
+
+  - Setup command shows its work (not a black box)
+  - Review process is transparent in logs
+  - Easier to diagnose when things actually break
+
+  **Backward compatible:** Yes. Existing agents checking for `success: false` will still work, they just won't see false errors anymore.
+
+## 0.30.0
+
+### Minor Changes
+
+- [`f3917ad`](https://github.com/joelhooks/swarm-tools/commit/f3917ad911d3c716a2470a01c66bce3500f644f4) Thanks [@joelhooks](https://github.com/joelhooks)! - ## 🐝 The Great bd CLI Purge
+
+  The `bd` CLI is officially dead. Long live HiveAdapter!
+
+  **What changed:**
+
+  ### `swarm init` Command Rewritten
+
+  - No longer shells out to `bd init` or `bd create`
+  - Uses `ensureHiveDirectory()` and `getHiveAdapter()` directly
+  - Supports `.beads` → `.hive` migration with user prompts
+  - Creates cells via HiveAdapter, not CLI
+
+  ### Auto-sync Removed from `index.ts`
+
+  - Removed `void $\`bd sync\`.quiet().nothrow()`after`hive_close`
+  - Users should call `hive_sync` explicitly at session end
+  - This was a fire-and-forget that could race with other operations
+
+  ### Plugin Template Updated
+
+  - `detectSwarm()` now has confidence levels (HIGH/MEDIUM/LOW/NONE)
+  - Added `SWARM_DETECTION_FALLBACK` for uncertain cases
+  - Compaction hook injects context based on confidence:
+    - HIGH/MEDIUM → Full swarm context
+    - LOW → Fallback detection prompt
+    - NONE → No injection
+
+  ### Error Handling Fixed
+
+  - `execTool()` now handles both string and object error formats
+  - Fixes "Tool execution failed" generic error from `swarm_complete`
+  - Actual error messages now propagate to the agent
+
+  **Why it matters:**
+
+  - No external CLI dependency for core functionality
+  - HiveAdapter is type-safe and testable
+  - Plugin works in environments without `bd` installed
+  - Better error messages for debugging
+
+  **Migration:** Run `swarm setup` to update your deployed plugin.
+
 ## 0.29.0
 
 ### Minor Changes

package/README.md

@@ -220,7 +220,8 @@ These tools significantly enhance the swarm experience:
 |------|---------|---------|
 | [CASS](https://github.com/Dicklesworthstone/coding_agent_session_search) | Historical context - queries past sessions for similar decompositions | See below |
 | [UBS](https://github.com/Dicklesworthstone/ultimate_bug_scanner) | Bug scanning - runs on subtask completion to catch issues | See below |
-| [semantic-memory](https://github.com/joelhooks/semantic-memory) | Learning persistence - stores patterns across sessions | Requires Ollama (see above) |
+
+> **Note:** Semantic memory is now embedded in the plugin. No separate installation needed - just install Ollama for vector embeddings.
 
 #### Installing CASS
 
@@ -243,15 +244,11 @@ cd ultimate_bug_scanner
 pip install -e .
 ```
 
-#### Installing semantic-memory
-
-The `semantic-memory_check` tool verifies Ollama is ready (see installation steps above).
-
 **Why install these?**
 
 - **CASS** - When you run `/swarm "Add OAuth"`, the coordinator queries CASS for similar past tasks. Without it, decomposition is based only on the current task description.
 - **UBS** - Every `swarm_complete` runs UBS to scan for bugs. Without it, you lose automatic bug detection.
-- **semantic-memory** - Pattern maturity and anti-pattern detection persist across sessions. Without it, learning resets each session.
+- **Ollama** - Enables vector similarity search for semantic memory. Without it, memory falls back to full-text search (still functional, less semantic).
 
 Run `swarm doctor` to check which dependencies are installed.
 

package/bin/swarm.test.ts

@@ -0,0 +1,163 @@
+#!/usr/bin/env bun
+/**
+ * Tests for swarm CLI file operation helpers
+ * 
+ * These tests verify the verbose output helpers used in `swarm setup`:
+ * - writeFileWithStatus: logs created/updated/unchanged status
+ * - mkdirWithStatus: logs directory creation
+ * - rmWithStatus: logs file removal
+ */
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+type FileStatus = "created" | "updated" | "unchanged";
+
+/**
+ * Mock logger for testing (matches @clack/prompts API)
+ */
+class MockLogger {
+  logs: Array<{ type: string; message: string }> = [];
+
+  success(msg: string) {
+    this.logs.push({ type: "success", message: msg });
+  }
+
+  message(msg: string) {
+    this.logs.push({ type: "message", message: msg });
+  }
+
+  reset() {
+    this.logs = [];
+  }
+}
+
+describe("File operation helpers", () => {
+  let testDir: string;
+  let logger: MockLogger;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `swarm-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+    logger = new MockLogger();
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe("writeFileWithStatus", () => {
+    // Helper that mimics the implementation
+    function writeFileWithStatus(path: string, content: string, label: string): FileStatus {
+      const exists = existsSync(path);
+      
+      if (exists) {
+        const current = readFileSync(path, "utf-8");
+        if (current === content) {
+          logger.message(`  ${label}: ${path} (unchanged)`);
+          return "unchanged";
+        }
+      }
+      
+      writeFileSync(path, content);
+      const status: FileStatus = exists ? "updated" : "created";
+      logger.success(`${label}: ${path} (${status})`);
+      return status;
+    }
+
+    test("returns 'created' for new file", () => {
+      const filePath = join(testDir, "new.txt");
+      const result = writeFileWithStatus(filePath, "content", "Test");
+      
+      expect(result).toBe("created");
+      expect(logger.logs[0].type).toBe("success");
+      expect(logger.logs[0].message).toContain("(created)");
+      expect(existsSync(filePath)).toBe(true);
+    });
+
+    test("returns 'unchanged' if content is same", () => {
+      const filePath = join(testDir, "existing.txt");
+      writeFileSync(filePath, "same content");
+      
+      const result = writeFileWithStatus(filePath, "same content", "Test");
+      
+      expect(result).toBe("unchanged");
+      expect(logger.logs[0].type).toBe("message");
+      expect(logger.logs[0].message).toContain("(unchanged)");
+    });
+
+    test("returns 'updated' if content differs", () => {
+      const filePath = join(testDir, "existing.txt");
+      writeFileSync(filePath, "old content");
+      
+      const result = writeFileWithStatus(filePath, "new content", "Test");
+      
+      expect(result).toBe("updated");
+      expect(logger.logs[0].type).toBe("success");
+      expect(logger.logs[0].message).toContain("(updated)");
+      expect(readFileSync(filePath, "utf-8")).toBe("new content");
+    });
+  });
+
+  describe("mkdirWithStatus", () => {
+    function mkdirWithStatus(path: string): boolean {
+      if (!existsSync(path)) {
+        mkdirSync(path, { recursive: true });
+        logger.message(`  Created directory: ${path}`);
+        return true;
+      }
+      return false;
+    }
+
+    test("creates directory and logs when it doesn't exist", () => {
+      const dirPath = join(testDir, "newdir");
+      const result = mkdirWithStatus(dirPath);
+      
+      expect(result).toBe(true);
+      expect(existsSync(dirPath)).toBe(true);
+      expect(logger.logs[0].type).toBe("message");
+      expect(logger.logs[0].message).toContain("Created directory");
+    });
+
+    test("returns false when directory already exists", () => {
+      const dirPath = join(testDir, "existing");
+      mkdirSync(dirPath);
+      
+      const result = mkdirWithStatus(dirPath);
+      
+      expect(result).toBe(false);
+      expect(logger.logs.length).toBe(0);
+    });
+  });
+
+  describe("rmWithStatus", () => {
+    function rmWithStatus(path: string, label: string): void {
+      if (existsSync(path)) {
+        rmSync(path);
+        logger.message(`  Removed ${label}: ${path}`);
+      }
+    }
+
+    test("removes file and logs when it exists", () => {
+      const filePath = join(testDir, "todelete.txt");
+      writeFileSync(filePath, "content");
+      
+      rmWithStatus(filePath, "test file");
+      
+      expect(existsSync(filePath)).toBe(false);
+      expect(logger.logs[0].type).toBe("message");
+      expect(logger.logs[0].message).toContain("Removed test file");
+    });
+
+    test("does nothing when file doesn't exist", () => {
+      const filePath = join(testDir, "nonexistent.txt");
+      
+      rmWithStatus(filePath, "test file");
+      
+      expect(logger.logs.length).toBe(0);
+    });
+  });
+});