opencode-swarm-plugin 0.34.0 → 0.36.0

package/CHANGELOG.md

@@ -1,5 +1,102 @@
 # opencode-swarm-plugin
 
+## 0.36.0
+
+### Minor Changes
+
+- [`ae213aa`](https://github.com/joelhooks/swarm-tools/commit/ae213aa49be977e425e0a767b5b2db16e462f76b) Thanks [@joelhooks](https://github.com/joelhooks)! - ## 🔬 Compaction Hook: Now With X-Ray Vision
+
+  The compaction hook was logging to `console.log` like a caveman. Now it writes structured JSON logs to `~/.config/swarm-tools/logs/compaction.log` - visible via `swarm log compaction`.
+
+  **The Problem:**
+
+  - Plugin wrapper used `console.log` → stdout → invisible
+  - npm package had pino logging → but wrapper didn't use it
+  - Running `/compact` gave zero visibility into what happened
+
+  **The Fix:**
+  Added comprehensive file-based logging throughout the compaction flow:
+
+  ```
+  ┌─────────────────────────────────────────────────────────────┐
+  │                    COMPACTION LOGGING                       │
+  ├─────────────────────────────────────────────────────────────┤
+  │  compaction_hook_invoked     │ Full input/output objects    │
+  │  detect_swarm_*              │ CLI calls, cells, confidence │
+  │  query_swarm_state_*         │ Epic/subtask extraction      │
+  │  generate_compaction_prompt_*│ LLM timing, success/failure  │
+  │  context_injected_via_*      │ Which API used               │
+  │  compaction_complete_*       │ Final result + timing        │
+  └─────────────────────────────────────────────────────────────┘
+  ```
+
+  **Also Enhanced:**
+
+  - SDK message scanning for precise swarm state extraction
+  - Merged scanned state (ground truth) with hive detection (heuristic)
+  - 9 new tests for `scanSessionMessages()` (32 total passing)
+
+  **To See It Work:**
+
+  ```bash
+  swarm setup --reinstall  # Regenerate plugin wrapper
+  # Run /compact in OpenCode
+  swarm log compaction     # See what happened
+  ```
+
+### Patch Changes
+
+- [`5cfc42e`](https://github.com/joelhooks/swarm-tools/commit/5cfc42e93d3e5424e308857a40af4fd9fbda0ba3) Thanks [@joelhooks](https://github.com/joelhooks)! - ## 🐝 Swarm Workers Unchained
+
+  Removed the vestigial `max_subtasks` parameter from decomposition tools. It was dead code - the prompts already say "as many as needed" and the replacement was doing nothing.
+
+  **What changed:**
+
+  - Removed `max_subtasks` arg from `swarm_decompose`, `swarm_plan_prompt`, `swarm_delegate_planning`
+  - Removed from `DecomposeArgsSchema`
+  - Renamed `max_subtasks` → `subtask_count` in eval capture (records actual count, not a limit)
+  - Cleaned up tests that were passing the unused parameter
+
+  **Why it matters:**
+  The LLM decides how many subtasks based on task complexity, not an arbitrary cap. "Plan aggressively" means spawn as many workers as the task needs.
+
+  **No functional change** - the parameter wasn't being used anyway.
+
+## 0.35.0
+
+### Minor Changes
+
+- [`084f888`](https://github.com/joelhooks/swarm-tools/commit/084f888fcac4912f594428b1ac7148c8a8aaa422) Thanks [@joelhooks](https://github.com/joelhooks)! - ## 👁️ Watch Your Swarm in Real-Time
+
+  `swarm log` now has a `--watch` mode for continuous log monitoring. No more running the command repeatedly - just sit back and watch the bees work.
+
+  ```bash
+  # Watch all logs
+  swarm log --watch
+
+  # Watch with filters
+  swarm log compaction -w --level error
+
+  # Faster polling (500ms instead of default 1s)
+  swarm log --watch --interval 500
+  ```
+
+  **New flags:**
+
+  - `--watch`, `-w` - Enable continuous monitoring mode
+  - `--interval <ms>` - Poll interval in milliseconds (default: 1000, min: 100)
+
+  **How it works:**
+
+  - Shows initial logs (last N lines based on `--limit`)
+  - Polls log files for new entries at the specified interval
+  - Tracks file positions for efficient incremental reads
+  - Handles log rotation gracefully (detects file truncation)
+  - All existing filters work: `--level`, `--since`, module name
+  - Clean shutdown on Ctrl+C
+
+  _"The hive that watches itself, debugs itself."_
+
 ## 0.34.0
 
 ### Minor Changes

package/bin/swarm.test.ts

@@ -462,4 +462,74 @@ describe("Log command helpers", () => {
       expect(lines).toHaveLength(0);
     });
   });
+
+  describe("watchLogs", () => {
+    test("detects new log lines appended to file", async () => {
+      const logFile = join(testDir, "swarm.1log");
+      const collectedLines: string[] = [];
+      
+      // Create initial log file
+      writeFileSync(logFile, '{"level":30,"time":"2024-12-24T16:00:00.000Z","msg":"initial"}\n');
+      
+      // Import watch utilities
+      const { watch } = await import("fs");
+      const { appendFileSync } = await import("fs");
+      
+      // Track file position for incremental reads
+      let lastSize = 0;
+      
+      function readNewLines(filePath: string): string[] {
+        const content = readFileSync(filePath, "utf-8");
+        const newContent = content.slice(lastSize);
+        lastSize = content.length;
+        return newContent.split("\n").filter((line) => line.trim());
+      }
+      
+      // Simulate watch behavior
+      const watcher = watch(testDir, (eventType, filename) => {
+        if (filename && /\.\d+log$/.test(filename)) {
+          const newLines = readNewLines(join(testDir, filename));
+          collectedLines.push(...newLines);
+        }
+      });
+      
+      // Wait for watcher to be ready
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      
+      // Append new log line
+      appendFileSync(logFile, '{"level":30,"time":"2024-12-24T16:00:01.000Z","msg":"appended"}\n');
+      
+      // Wait for event to fire
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      
+      watcher.close();
+      
+      // Should have detected the new line
+      expect(collectedLines.some((l) => l.includes("appended"))).toBe(true);
+    });
+
+    test("parseWatchArgs extracts --watch flag", () => {
+      function parseWatchArgs(args: string[]): { watch: boolean; interval: number } {
+        let watch = false;
+        let interval = 1000; // default 1 second
+        
+        for (let i = 0; i < args.length; i++) {
+          const arg = args[i];
+          if (arg === "--watch" || arg === "-w") {
+            watch = true;
+          } else if (arg === "--interval" && i + 1 < args.length) {
+            interval = parseInt(args[++i], 10);
+          }
+        }
+        
+        return { watch, interval };
+      }
+      
+      expect(parseWatchArgs(["--watch"])).toEqual({ watch: true, interval: 1000 });
+      expect(parseWatchArgs(["-w"])).toEqual({ watch: true, interval: 1000 });
+      expect(parseWatchArgs(["--watch", "--interval", "500"])).toEqual({ watch: true, interval: 500 });
+      expect(parseWatchArgs(["compaction", "--watch"])).toEqual({ watch: true, interval: 1000 });
+      expect(parseWatchArgs(["--level", "error"])).toEqual({ watch: false, interval: 1000 });
+    });
+  });
 });

package/bin/swarm.ts

@@ -2732,6 +2732,8 @@ ${cyan("Log Viewing:")}
   swarm log --since <duration>         Time filter (30s, 5m, 2h, 1d)
   swarm log --json                     Raw JSON output for jq
   swarm log --limit <n>                Limit output to n lines (default: 50)
+  swarm log --watch, -w                Watch mode - continuously monitor for new logs
+  swarm log --interval <ms>            Poll interval in ms (default: 1000, min: 100)
 
 ${cyan("Usage in OpenCode:")}
   /swarm "Add user authentication with OAuth"
@@ -3203,6 +3205,8 @@ async function logs() {
   let sinceMs: number | null = null;
   let jsonOutput = false;
   let limit = 50;
+  let watchMode = false;
+  let pollInterval = 1000; // 1 second default
   
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -3225,7 +3229,15 @@ async function logs() {
         p.log.error(`Invalid limit: ${args[i]}`);
         process.exit(1);
       }
-    } else if (!arg.startsWith("--")) {
+    } else if (arg === "--watch" || arg === "-w") {
+      watchMode = true;
+    } else if (arg === "--interval" && i + 1 < args.length) {
+      pollInterval = parseInt(args[++i], 10);
+      if (isNaN(pollInterval) || pollInterval < 100) {
+        p.log.error(`Invalid interval: ${args[i]} (minimum 100ms)`);
+        process.exit(1);
+      }
+    } else if (!arg.startsWith("--") && !arg.startsWith("-")) {
       // Positional arg = module filter
       moduleFilter = arg;
     }
@@ -3244,6 +3256,131 @@ async function logs() {
     return;
   }
   
+  // Helper to filter logs
+  const filterLogs = (rawLogs: LogLine[]): LogLine[] => {
+    let filtered = rawLogs;
+    
+    if (moduleFilter) {
+      filtered = filtered.filter((log) => log.module === moduleFilter);
+    }
+    
+    if (levelFilter !== null) {
+      filtered = filtered.filter((log) => log.level >= levelFilter);
+    }
+    
+    if (sinceMs !== null) {
+      const cutoffTime = Date.now() - sinceMs;
+      filtered = filtered.filter((log) => new Date(log.time).getTime() >= cutoffTime);
+    }
+    
+    return filtered;
+  };
+  
+  // Watch mode - continuous monitoring
+  if (watchMode) {
+    console.log(yellow(BANNER));
+    console.log(dim(`  Watching logs... (Ctrl+C to stop)`));
+    if (moduleFilter) console.log(dim(`  Module: ${moduleFilter}`));
+    if (levelFilter !== null) console.log(dim(`  Level: >=${levelToName(levelFilter)}`));
+    console.log();
+    
+    // Track file positions for incremental reads
+    const filePositions: Map<string, number> = new Map();
+    
+    // Initialize positions from current file sizes
+    const initializePositions = () => {
+      if (!existsSync(logsDir)) return;
+      const files = readdirSync(logsDir).filter((f: string) => /\.\d+log$/.test(f));
+      for (const file of files) {
+        const filePath = join(logsDir, file);
+        try {
+          const stats = statSync(filePath);
+          filePositions.set(filePath, stats.size);
+        } catch {
+          // Skip unreadable files
+        }
+      }
+    };
+    
+    // Read new lines from a file since last position
+    const readNewLines = (filePath: string): string[] => {
+      try {
+        const stats = statSync(filePath);
+        const lastPos = filePositions.get(filePath) || 0;
+        
+        if (stats.size <= lastPos) {
+          // File was truncated or no new content
+          if (stats.size < lastPos) {
+            filePositions.set(filePath, stats.size);
+          }
+          return [];
+        }
+        
+        const content = readFileSync(filePath, "utf-8");
+        const newContent = content.slice(lastPos);
+        filePositions.set(filePath, stats.size);
+        
+        return newContent.split("\n").filter((line: string) => line.trim());
+      } catch {
+        return [];
+      }
+    };
+    
+    // Print initial logs (last N lines)
+    const rawLines = readLogFiles(logsDir);
+    let logs: LogLine[] = rawLines
+      .map(parseLogLine)
+      .filter((log): log is LogLine => log !== null);
+    logs = filterLogs(logs).slice(-limit);
+    
+    for (const log of logs) {
+      console.log(formatLogLine(log));
+    }
+    
+    // Initialize positions after printing initial logs
+    initializePositions();
+    
+    // Poll for new logs
+    const pollForNewLogs = () => {
+      if (!existsSync(logsDir)) return;
+      
+      const files = readdirSync(logsDir).filter((f: string) => /\.\d+log$/.test(f));
+      
+      for (const file of files) {
+        const filePath = join(logsDir, file);
+        const newLines = readNewLines(filePath);
+        
+        for (const line of newLines) {
+          const parsed = parseLogLine(line);
+          if (parsed) {
+            const filtered = filterLogs([parsed]);
+            if (filtered.length > 0) {
+              console.log(formatLogLine(filtered[0]));
+            }
+          }
+        }
+      }
+    };
+    
+    // Set up polling interval
+    const intervalId = setInterval(pollForNewLogs, pollInterval);
+    
+    // Handle graceful shutdown
+    const cleanup = () => {
+      clearInterval(intervalId);
+      console.log(dim("\n  Stopped watching."));
+      process.exit(0);
+    };
+    
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    
+    // Keep process alive
+    await new Promise(() => {});
+    return;
+  }
+  
+  // Non-watch mode - one-shot output
   const rawLines = readLogFiles(logsDir);
   
   // Parse and filter
@@ -3251,19 +3388,7 @@ async function logs() {
     .map(parseLogLine)
     .filter((log): log is LogLine => log !== null);
   
-  // Apply filters
-  if (moduleFilter) {
-    logs = logs.filter((log) => log.module === moduleFilter);
-  }
-  
-  if (levelFilter !== null) {
-    logs = logs.filter((log) => log.level >= levelFilter);
-  }
-  
-  if (sinceMs !== null) {
-    const cutoffTime = Date.now() - sinceMs;
-    logs = logs.filter((log) => new Date(log.time).getTime() >= cutoffTime);
-  }
+  logs = filterLogs(logs);
   
   // Apply limit (keep most recent)
   logs = logs.slice(-limit);