opencode-swarm-plugin 0.33.0 → 0.34.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-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);
+  });
+});

package/src/swarm-prompts.ts

@@ -743,10 +743,32 @@ swarm_review_feedback(
 )
 \`\`\`
 
-### Step 5: ONLY THEN Continue
-- If approved: Close the cell, spawn next worker
-- If needs_changes: Worker gets feedback, retries (max 3 attempts)
-- If 3 failures: Mark blocked, escalate to human
+### Step 5: Take Action Based on Review
+
+**If APPROVED:**
+- Close the cell with hive_close
+- Spawn next worker (if any) using swarm_spawn_subtask
+
+**If NEEDS_CHANGES:**
+- Generate retry prompt:
+  \`\`\`
+  swarm_spawn_retry(
+    bead_id="{task_id}",
+    epic_id="{epic_id}",
+    original_prompt="<original prompt>",
+    attempt=<current_attempt>,
+    issues="<JSON from swarm_review_feedback>",
+    diff="<git diff of previous changes>",
+    files=[{files_touched}],
+    project_path="{project_key}"
+  )
+  \`\`\`
+- Spawn new worker with Task() using the retry prompt
+- Increment attempt counter (max 3 attempts)
+
+**If 3 FAILURES:**
+- Mark task as blocked: \`hive_update(id="{task_id}", status="blocked")\`
+- Escalate to human - likely an architectural problem, not execution issue
 
 **⚠️ DO NOT spawn the next worker until review is complete.**
 `;
@@ -1164,6 +1186,157 @@ export const swarm_spawn_researcher = tool({
   },
 });
 
+/**
+ * Generate retry prompt for a worker that needs to fix issues from review feedback
+ * 
+ * Coordinators use this when swarm_review_feedback returns "needs_changes".
+ * Creates a new worker spawn with context about what went wrong and what to fix.
+ */
+export const swarm_spawn_retry = tool({
+  description:
+    "Generate retry prompt for a worker that failed review. Includes issues from previous attempt, diff if provided, and standard worker contract.",
+  args: {
+    bead_id: tool.schema.string().describe("Original subtask bead ID"),
+    epic_id: tool.schema.string().describe("Parent epic bead ID"),
+    original_prompt: tool.schema.string().describe("The prompt given to failed worker"),
+    attempt: tool.schema.number().int().min(1).max(3).describe("Current attempt number (1, 2, or 3)"),
+    issues: tool.schema.string().describe("JSON array of ReviewIssue objects from swarm_review_feedback"),
+    diff: tool.schema
+      .string()
+      .optional()
+      .describe("Git diff of previous changes"),
+    files: tool.schema
+      .array(tool.schema.string())
+      .describe("Files to modify (from original subtask)"),
+    project_path: tool.schema
+      .string()
+      .optional()
+      .describe("Absolute project path for swarmmail_init"),
+  },
+  async execute(args) {
+    // Validate attempt number
+    if (args.attempt > 3) {
+      throw new Error(
+        `Retry attempt ${args.attempt} exceeds maximum of 3. After 3 failures, task should be marked blocked.`,
+      );
+    }
+
+    // Parse issues
+    let issuesArray: Array<{
+      file: string;
+      line: number;
+      issue: string;
+      suggestion: string;
+    }> = [];
+    try {
+      issuesArray = JSON.parse(args.issues);
+    } catch (e) {
+      // If issues is not valid JSON, treat as empty array
+      issuesArray = [];
+    }
+
+    // Format issues section
+    const issuesSection = issuesArray.length > 0
+      ? `## ISSUES FROM PREVIOUS ATTEMPT
+
+The previous attempt had the following issues that need to be fixed:
+
+${issuesArray
+  .map(
+    (issue, idx) =>
+      `**${idx + 1}. ${issue.file}:${issue.line}**
+   - **Issue**: ${issue.issue}
+   - **Suggestion**: ${issue.suggestion}`,
+  )
+  .join("\n\n")}
+
+**Critical**: Fix these issues while preserving any working changes from the previous attempt.`
+      : "";
+
+    // Format diff section
+    const diffSection = args.diff
+      ? `## PREVIOUS ATTEMPT
+
+Here's what was tried in the previous attempt:
+
+\`\`\`diff
+${args.diff}
+\`\`\`
+
+Review this carefully - some changes may be correct and should be preserved.`
+      : "";
+
+    // Build the retry prompt
+    const retryPrompt = `⚠️ **RETRY ATTEMPT ${args.attempt}/3**
+
+This is a retry of a previously attempted subtask. The coordinator reviewed the previous attempt and found issues that need to be fixed.
+
+${issuesSection}
+
+${diffSection}
+
+## ORIGINAL TASK
+
+${args.original_prompt}
+
+## YOUR MISSION
+
+1. **Understand what went wrong** - Read the issues carefully
+2. **Fix the specific problems** - Address each issue listed above
+3. **Preserve working code** - Don't throw away correct changes from previous attempt
+4. **Follow the standard worker contract** - See below
+
+## MANDATORY WORKER CONTRACT
+
+### Step 1: Initialize (REQUIRED FIRST)
+\`\`\`
+swarmmail_init(project_path="${args.project_path || "$PWD"}", task_description="${args.bead_id}: Retry ${args.attempt}/3")
+\`\`\`
+
+### Step 2: Reserve Files
+\`\`\`
+swarmmail_reserve(
+  paths=${JSON.stringify(args.files)},
+  reason="${args.bead_id}: Retry attempt ${args.attempt}",
+  exclusive=true
+)
+\`\`\`
+
+### Step 3: Fix the Issues
+- Address each issue listed above
+- Run tests to verify fixes
+- Don't introduce new bugs
+
+### Step 4: Complete
+\`\`\`
+swarm_complete(
+  project_key="${args.project_path || "$PWD"}",
+  agent_name="<your-agent-name>",
+  bead_id="${args.bead_id}",
+  summary="Fixed issues from review: <brief summary>",
+  files_touched=[<files you modified>]
+)
+\`\`\`
+
+**Remember**: This is attempt ${args.attempt} of 3. If this fails review again, there may be an architectural problem that needs human intervention.
+
+Begin work now.`;
+
+    return JSON.stringify(
+      {
+        prompt: retryPrompt,
+        bead_id: args.bead_id,
+        attempt: args.attempt,
+        max_attempts: 3,
+        files: args.files,
+        issues_count: issuesArray.length,
+      },
+      null,
+      2,
+    );
+  },
+});
+
 /**
  * Generate self-evaluation prompt
  */
@@ -1353,6 +1526,7 @@ export const promptTools = {
   swarm_subtask_prompt,
   swarm_spawn_subtask,
   swarm_spawn_researcher,
+  swarm_spawn_retry,
   swarm_evaluation_prompt,
   swarm_plan_prompt,
 };

package/src/swarm-review.test.ts

@@ -700,3 +700,180 @@ describe("edge cases", () => {
     expect(prompt).toContain(longDiff);
   });
 });
+
+// ============================================================================
+// Coordinator-Driven Retry: swarm_review_feedback returns retry_context
+// ============================================================================
+
+describe("swarm_review_feedback retry_context", () => {
+  beforeEach(() => {
+    clearReviewStatus("bd-retry-test");
+    vi.clearAllMocks();
+  });
+
+  it("returns retry_context when status is needs_changes", async () => {
+    const issues = JSON.stringify([
+      { file: "src/auth.ts", line: 42, issue: "Missing null check", suggestion: "Add null check" }
+    ]);
+
+    const result = await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "needs_changes",
+        issues,
+      },
+      mockContext
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.success).toBe(true);
+    expect(parsed.status).toBe("needs_changes");
+    // NEW: Should include retry_context for coordinator
+    expect(parsed).toHaveProperty("retry_context");
+    expect(parsed.retry_context).toHaveProperty("task_id", "bd-retry-test");
+    expect(parsed.retry_context).toHaveProperty("attempt", 1);
+    expect(parsed.retry_context).toHaveProperty("issues");
+    expect(parsed.retry_context.issues).toHaveLength(1);
+  });
+
+  it("retry_context includes issues in structured format", async () => {
+    const issues = [
+      { file: "src/a.ts", line: 10, issue: "Bug A", suggestion: "Fix A" },
+      { file: "src/b.ts", line: 20, issue: "Bug B", suggestion: "Fix B" },
+    ];
+
+    const result = await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "needs_changes",
+        issues: JSON.stringify(issues),
+      },
+      mockContext
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.retry_context.issues).toEqual(issues);
+  });
+
+  it("retry_context includes next_action hint for coordinator", async () => {
+    const issues = JSON.stringify([{ file: "x.ts", issue: "bug" }]);
+
+    const result = await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "needs_changes",
+        issues,
+      },
+      mockContext
+    );
+
+    const parsed = JSON.parse(result);
+    // Should tell coordinator what to do next
+    expect(parsed.retry_context).toHaveProperty("next_action");
+    expect(parsed.retry_context.next_action).toContain("swarm_spawn_retry");
+  });
+
+  it("does NOT include retry_context when approved", async () => {
+    const result = await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "approved",
+        summary: "Looks good!",
+      },
+      mockContext
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.success).toBe(true);
+    expect(parsed.status).toBe("approved");
+    expect(parsed).not.toHaveProperty("retry_context");
+  });
+
+  it("does NOT include retry_context when task fails (3 attempts)", async () => {
+    const issues = JSON.stringify([{ file: "x.ts", issue: "still broken" }]);
+
+    // Exhaust all attempts
+    let result: string = "";
+    for (let i = 0; i < 3; i++) {
+      result = await swarm_review_feedback.execute(
+        {
+          project_key: "/tmp/test-project",
+          task_id: "bd-retry-test",
+          worker_id: "worker-test",
+          status: "needs_changes",
+          issues,
+        },
+        mockContext
+      );
+    }
+
+    const parsed = JSON.parse(result);
+    expect(parsed.task_failed).toBe(true);
+    // No retry_context when task is failed - nothing more to retry
+    expect(parsed).not.toHaveProperty("retry_context");
+  });
+
+  it("retry_context includes max_attempts for coordinator awareness", async () => {
+    const issues = JSON.stringify([{ file: "x.ts", issue: "bug" }]);
+
+    const result = await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "needs_changes",
+        issues,
+      },
+      mockContext
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.retry_context).toHaveProperty("max_attempts", 3);
+  });
+
+  it("does NOT send message to dead worker for needs_changes", async () => {
+    const { sendSwarmMessage } = await import("swarm-mail");
+    const issues = JSON.stringify([{ file: "x.ts", issue: "bug" }]);
+
+    await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "needs_changes",
+        issues,
+      },
+      mockContext
+    );
+
+    // Should NOT call sendSwarmMessage for needs_changes
+    // Workers are dead - they can't read messages
+    expect(sendSwarmMessage).not.toHaveBeenCalled();
+  });
+
+  it("DOES send message for approved status (audit trail)", async () => {
+    const { sendSwarmMessage } = await import("swarm-mail");
+
+    await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "approved",
+        summary: "Good work!",
+      },
+      mockContext
+    );
+
+    // Approved messages are still sent for audit trail
+    expect(sendSwarmMessage).toHaveBeenCalled();
+  });
+});