opencode-swarm-plugin 0.33.0 → 0.35.0

package/src/logger.test.ts

@@ -0,0 +1,189 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdir, rm, readdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+describe("Logger Infrastructure", () => {
+  const testLogDir = join(homedir(), ".config", "swarm-tools", "logs-test");
+  let originalEnv: string | undefined;
+
+  beforeEach(async () => {
+    // Clean up test log directory
+    if (existsSync(testLogDir)) {
+      await rm(testLogDir, { recursive: true, force: true });
+    }
+    await mkdir(testLogDir, { recursive: true });
+    originalEnv = process.env.SWARM_LOG_PRETTY;
+
+    // Clear module cache to reset logger instances
+    delete require.cache[require.resolve("./logger")];
+  });
+
+  afterEach(async () => {
+    // Restore environment
+    if (originalEnv !== undefined) {
+      process.env.SWARM_LOG_PRETTY = originalEnv;
+    } else {
+      delete process.env.SWARM_LOG_PRETTY;
+    }
+
+    // Clean up test directory
+    if (existsSync(testLogDir)) {
+      await rm(testLogDir, { recursive: true, force: true });
+    }
+  });
+
+  describe("getLogger", () => {
+    test("returns a valid Pino logger instance", async () => {
+      const { getLogger } = await import("./logger");
+      const logger = getLogger(testLogDir);
+
+      expect(logger).toBeDefined();
+      expect(typeof logger.info).toBe("function");
+      expect(typeof logger.error).toBe("function");
+      expect(typeof logger.debug).toBe("function");
+      expect(typeof logger.warn).toBe("function");
+    });
+
+    test("creates log directory if it doesn't exist", async () => {
+      const newDir = join(testLogDir, "nested", "path");
+      const { getLogger } = await import("./logger");
+
+      getLogger(newDir);
+
+      expect(existsSync(newDir)).toBe(true);
+    });
+
+    test("creates log file with numeric rotation pattern", async () => {
+      const { getLogger } = await import("./logger");
+      const logger = getLogger(testLogDir);
+
+      // Write a log to force file creation
+      logger.info("test message");
+
+      // Wait for async file creation (pino-roll is async)
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
+      const files = await readdir(testLogDir);
+      // pino-roll format: {filename}.{number}log (e.g., swarm.1log)
+      const logFile = files.find((f) => f.match(/^swarm\.\d+log$/));
+
+      expect(logFile).toBeDefined();
+    });
+
+    test("writes log entries to file", async () => {
+      const { getLogger } = await import("./logger");
+      const logger = getLogger(testLogDir);
+
+      logger.info("test log entry");
+      logger.error("test error entry");
+
+      // Wait for async file writes
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
+      const files = await readdir(testLogDir);
+      expect(files.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("createChildLogger", () => {
+    test("creates child logger with module namespace", async () => {
+      const { getLogger, createChildLogger } = await import("./logger");
+      getLogger(testLogDir); // Initialize main logger
+
+      const childLogger = createChildLogger("compaction", testLogDir);
+
+      expect(childLogger).toBeDefined();
+      expect(typeof childLogger.info).toBe("function");
+    });
+
+    test("child logger writes to module-specific file", async () => {
+      const { getLogger, createChildLogger } = await import("./logger");
+      getLogger(testLogDir);
+
+      const childLogger = createChildLogger("compaction", testLogDir);
+      childLogger.info("compaction test message");
+
+      // Wait for async file writes
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
+      const files = await readdir(testLogDir);
+      // pino-roll format: {module}.{number}log (e.g., compaction.1log)
+      const compactionLog = files.find((f) => f.match(/^compaction\.\d+log$/));
+
+      expect(compactionLog).toBeDefined();
+    });
+
+    test("multiple child loggers write to separate files", async () => {
+      const { getLogger, createChildLogger } = await import("./logger");
+      getLogger(testLogDir);
+
+      const compactionLogger = createChildLogger("compaction", testLogDir);
+      const cliLogger = createChildLogger("cli", testLogDir);
+
+      compactionLogger.info("compaction message");
+      cliLogger.info("cli message");
+
+      // Wait for async file writes
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
+      const files = await readdir(testLogDir);
+      // pino-roll format: {module}.{number}log
+      const compactionLog = files.find((f) => f.match(/^compaction\.\d+log$/));
+      const cliLog = files.find((f) => f.match(/^cli\.\d+log$/));
+
+      expect(compactionLog).toBeDefined();
+      expect(cliLog).toBeDefined();
+    });
+  });
+
+  describe("Pretty mode", () => {
+    test("respects SWARM_LOG_PRETTY=1 environment variable", async () => {
+      process.env.SWARM_LOG_PRETTY = "1";
+
+      // Force reimport to pick up env var
+      delete require.cache[require.resolve("./logger")];
+      const { getLogger } = await import("./logger");
+
+      const logger = getLogger(testLogDir);
+
+      // If pretty mode is enabled, logger should have prettyPrint config
+      // We can't easily inspect Pino internals, but we can verify it doesn't throw
+      expect(logger).toBeDefined();
+      expect(typeof logger.info).toBe("function");
+
+      logger.info("pretty test message");
+    });
+
+    test("works without pretty mode by default", async () => {
+      delete process.env.SWARM_LOG_PRETTY;
+
+      // Force reimport
+      delete require.cache[require.resolve("./logger")];
+      const { getLogger } = await import("./logger");
+
+      const logger = getLogger(testLogDir);
+
+      expect(logger).toBeDefined();
+      logger.info("normal mode message");
+    });
+  });
+
+  describe("Log rotation", () => {
+    test("sets up daily rotation with 14-day retention", async () => {
+      const { getLogger } = await import("./logger");
+      const logger = getLogger(testLogDir);
+
+      // Write logs to trigger rotation setup
+      logger.info("rotation test");
+
+      // Wait for async file creation
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
+      // Verify log file exists (rotation config is internal to pino-roll)
+      const files = await readdir(testLogDir);
+      expect(files.length).toBeGreaterThan(0);
+    });
+  });
+});

package/src/logger.ts

@@ -0,0 +1,135 @@
+/**
+ * Logger infrastructure using Pino with daily rotation
+ *
+ * Features:
+ * - Daily log rotation via pino-roll (numeric format: swarm.1log, swarm.2log, etc.)
+ * - 14-day retention (14 files max in addition to current file)
+ * - Module-specific child loggers with separate log files
+ * - Pretty mode for development (SWARM_LOG_PRETTY=1 env var)
+ * - Logs to ~/.config/swarm-tools/logs/ by default
+ *
+ * Note: pino-roll uses numeric rotation (e.g., swarm.1log, swarm.2log) not date-based names.
+ * Files rotate daily based on frequency='daily', with a maximum of 14 retained files.
+ */
+
+import { mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { Logger } from "pino";
+import pino from "pino";
+
+const DEFAULT_LOG_DIR = join(homedir(), ".config", "swarm-tools", "logs");
+
+/**
+ * Creates the log directory if it doesn't exist
+ */
+function ensureLogDir(logDir: string): void {
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+}
+
+/**
+ * Creates a Pino transport with file rotation
+ *
+ * @param filename - Log file base name (e.g., "swarm" becomes swarm.1log, swarm.2log, etc.)
+ * @param logDir - Directory to store logs
+ */
+function createTransport(
+  filename: string,
+  logDir: string,
+): pino.TransportTargetOptions {
+  const isPretty = process.env.SWARM_LOG_PRETTY === "1";
+
+  if (isPretty) {
+    // Pretty mode - output to console with pino-pretty
+    return {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: "HH:MM:ss",
+        ignore: "pid,hostname",
+      },
+    };
+  }
+
+  // Production mode - file rotation with pino-roll
+  // pino-roll format: {file}.{number}{extension}
+  // So "swarm" becomes "swarm.1log", "swarm.2log", etc.
+  return {
+    target: "pino-roll",
+    options: {
+      file: join(logDir, filename),
+      frequency: "daily",
+      extension: "log",
+      limit: { count: 14 },
+      mkdir: true,
+    },
+  };
+}
+
+const loggerCache = new Map<string, Logger>();
+
+/**
+ * Gets or creates the main logger instance
+ *
+ * @param logDir - Optional log directory (defaults to ~/.config/swarm-tools/logs)
+ * @returns Pino logger instance
+ */
+export function getLogger(logDir: string = DEFAULT_LOG_DIR): Logger {
+  const cacheKey = `swarm:${logDir}`;
+
+  if (loggerCache.has(cacheKey)) {
+    return loggerCache.get(cacheKey)!;
+  }
+
+  ensureLogDir(logDir);
+
+  const logger = pino(
+    {
+      level: process.env.LOG_LEVEL || "info",
+      timestamp: pino.stdTimeFunctions.isoTime,
+    },
+    pino.transport(createTransport("swarm", logDir)),
+  );
+
+  loggerCache.set(cacheKey, logger);
+  return logger;
+}
+
+/**
+ * Creates a child logger for a specific module with its own log file
+ *
+ * @param module - Module name (e.g., "compaction", "cli")
+ * @param logDir - Optional log directory (defaults to ~/.config/swarm-tools/logs)
+ * @returns Child logger instance
+ */
+export function createChildLogger(
+  module: string,
+  logDir: string = DEFAULT_LOG_DIR,
+): Logger {
+  const cacheKey = `${module}:${logDir}`;
+
+  if (loggerCache.has(cacheKey)) {
+    return loggerCache.get(cacheKey)!;
+  }
+
+  ensureLogDir(logDir);
+
+  const childLogger = pino(
+    {
+      level: process.env.LOG_LEVEL || "info",
+      timestamp: pino.stdTimeFunctions.isoTime,
+    },
+    pino.transport(createTransport(module, logDir)),
+  );
+
+  const logger = childLogger.child({ module });
+  loggerCache.set(cacheKey, logger);
+  return logger;
+}
+
+/**
+ * Default logger instance for immediate use
+ */
+export const logger = getLogger();

package/src/swarm-decompose.ts

@@ -434,12 +434,6 @@ export const swarm_decompose = tool({
     "Generate decomposition prompt for breaking task into parallelizable subtasks. Optionally queries CASS for similar past tasks.",
   args: {
     task: tool.schema.string().min(1).describe("Task description to decompose"),
-    max_subtasks: tool.schema
-      .number()
-      .int()
-      .min(1)
-      .optional()
-      .describe("Suggested max subtasks (optional - LLM decides if not specified)"),
     context: tool.schema
       .string()
       .optional()
@@ -503,7 +497,6 @@ export const swarm_decompose = tool({
       : "## Additional Context\n(none provided)";
 
     const prompt = DECOMPOSITION_PROMPT.replace("{task}", args.task)
-      .replace("{max_subtasks}", (args.max_subtasks ?? 5).toString())
       .replace("{context_section}", contextSection);
 
     // Return the prompt and schema info for the caller

package/src/swarm-prompts.test.ts

@@ -218,7 +218,8 @@ describe("swarm_spawn_subtask tool", () => {
     expect(instructions).toContain("Step 3: Evaluate Against Criteria");
     expect(instructions).toContain("Step 4: Send Feedback");
     expect(instructions).toContain("swarm_review_feedback");
-    expect(instructions).toContain("Step 5: ONLY THEN Continue");
+    expect(instructions).toContain("Step 5: Take Action Based on Review");
+    expect(instructions).toContain("swarm_spawn_retry"); // Should include retry flow
   });
 
   test("post_completion_instructions substitutes placeholders", async () => {
@@ -655,3 +656,165 @@ describe("swarm_spawn_researcher tool", () => {
     expect(parsed.check_upgrades).toBe(true);
   });
 });
+
+describe("swarm_spawn_retry tool", () => {
+  test("generates valid retry prompt with issues", async () => {
+    const { swarm_spawn_retry } = await import("./swarm-prompts");
+    
+    const result = await swarm_spawn_retry.execute({
+      bead_id: "test-project-abc123-task1",
+      epic_id: "test-project-abc123-epic1",
+      original_prompt: "Original task: implement feature X",
+      attempt: 1,
+      issues: JSON.stringify([
+        { file: "src/feature.ts", line: 42, issue: "Missing null check", suggestion: "Add null check" }
+      ]),
+      files: ["src/feature.ts"],
+      project_path: "/Users/joel/Code/project",
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed).toHaveProperty("prompt");
+    expect(typeof parsed.prompt).toBe("string");
+    expect(parsed.prompt).toContain("RETRY ATTEMPT");
+    expect(parsed.prompt).toContain("Missing null check");
+  });
+
+  test("includes attempt number in prompt header", async () => {
+    const { swarm_spawn_retry } = await import("./swarm-prompts");
+    
+    const result = await swarm_spawn_retry.execute({
+      bead_id: "test-project-abc123-task1",
+      epic_id: "test-project-abc123-epic1",
+      original_prompt: "Original task",
+      attempt: 2,
+      issues: "[]",
+      files: ["src/test.ts"],
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed.prompt).toContain("RETRY ATTEMPT 2/3");
+    expect(parsed.attempt).toBe(2);
+  });
+
+  test("includes diff when provided", async () => {
+    const { swarm_spawn_retry } = await import("./swarm-prompts");
+    
+    const diffContent = `diff --git a/src/test.ts b/src/test.ts
++++ b/src/test.ts
+@@ -1 +1 @@
+-const x = 1;
++const x = null;`;
+
+    const result = await swarm_spawn_retry.execute({
+      bead_id: "test-project-abc123-task1",
+      epic_id: "test-project-abc123-epic1",
+      original_prompt: "Original task",
+      attempt: 1,
+      issues: "[]",
+      diff: diffContent,
+      files: ["src/test.ts"],
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed.prompt).toContain(diffContent);
+    expect(parsed.prompt).toContain("PREVIOUS ATTEMPT");
+  });
+
+  test("rejects attempt > 3 with error", async () => {
+    const { swarm_spawn_retry } = await import("./swarm-prompts");
+    
+    await expect(async () => {
+      await swarm_spawn_retry.execute({
+        bead_id: "test-project-abc123-task1",
+        epic_id: "test-project-abc123-epic1",
+        original_prompt: "Original task",
+        attempt: 4,
+        issues: "[]",
+        files: ["src/test.ts"],
+      });
+    }).toThrow(/attempt.*exceeds.*maximum/i);
+  });
+
+  test("formats issues as readable list", async () => {
+    const { swarm_spawn_retry } = await import("./swarm-prompts");
+    
+    const issues = [
+      { file: "src/a.ts", line: 10, issue: "Missing error handling", suggestion: "Add try-catch" },
+      { file: "src/b.ts", line: 20, issue: "Type mismatch", suggestion: "Fix types" }
+    ];
+
+    const result = await swarm_spawn_retry.execute({
+      bead_id: "test-project-abc123-task1",
+      epic_id: "test-project-abc123-epic1",
+      original_prompt: "Original task",
+      attempt: 1,
+      issues: JSON.stringify(issues),
+      files: ["src/a.ts", "src/b.ts"],
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed.prompt).toContain("ISSUES FROM PREVIOUS ATTEMPT");
+    expect(parsed.prompt).toContain("src/a.ts:10");
+    expect(parsed.prompt).toContain("Missing error handling");
+    expect(parsed.prompt).toContain("src/b.ts:20");
+    expect(parsed.prompt).toContain("Type mismatch");
+  });
+
+  test("returns expected response structure", async () => {
+    const { swarm_spawn_retry } = await import("./swarm-prompts");
+    
+    const result = await swarm_spawn_retry.execute({
+      bead_id: "test-project-abc123-task1",
+      epic_id: "test-project-abc123-epic1",
+      original_prompt: "Original task",
+      attempt: 1,
+      issues: "[]",
+      files: ["src/test.ts"],
+      project_path: "/Users/joel/Code/project",
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed).toHaveProperty("prompt");
+    expect(parsed).toHaveProperty("bead_id", "test-project-abc123-task1");
+    expect(parsed).toHaveProperty("attempt", 1);
+    expect(parsed).toHaveProperty("max_attempts", 3);
+    expect(parsed).toHaveProperty("files");
+    expect(parsed.files).toEqual(["src/test.ts"]);
+  });
+
+  test("includes standard worker contract (swarmmail_init, reserve, complete)", async () => {
+    const { swarm_spawn_retry } = await import("./swarm-prompts");
+    
+    const result = await swarm_spawn_retry.execute({
+      bead_id: "test-project-abc123-task1",
+      epic_id: "test-project-abc123-epic1",
+      original_prompt: "Original task",
+      attempt: 1,
+      issues: "[]",
+      files: ["src/test.ts"],
+      project_path: "/Users/joel/Code/project",
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed.prompt).toContain("swarmmail_init");
+    expect(parsed.prompt).toContain("swarmmail_reserve");
+    expect(parsed.prompt).toContain("swarm_complete");
+  });
+
+  test("instructs to preserve working changes", async () => {
+    const { swarm_spawn_retry } = await import("./swarm-prompts");
+    
+    const result = await swarm_spawn_retry.execute({
+      bead_id: "test-project-abc123-task1",
+      epic_id: "test-project-abc123-epic1",
+      original_prompt: "Original task",
+      attempt: 1,
+      issues: JSON.stringify([{ file: "src/test.ts", line: 1, issue: "Bug", suggestion: "Fix" }]),
+      files: ["src/test.ts"],
+    });
+
+    const parsed = JSON.parse(result);
+    expect(parsed.prompt).toMatch(/preserve.*working|fix.*while preserving/i);
+  });
+});