opencode-swarm-plugin 0.33.0 → 0.35.0

package/src/compaction-hook.ts

@@ -31,6 +31,28 @@
 
 import { getHiveAdapter, getHiveWorkingDirectory } from "./hive";
 import { checkSwarmHealth } from "swarm-mail";
+import { createChildLogger } from "./logger";
+
+let _logger: any | undefined;
+
+/**
+ * Get logger instance (lazy initialization for testability)
+ *
+ * Logs to: ~/.config/swarm-tools/logs/compaction.1log
+ *
+ * Log structure:
+ * - START: session_id, trigger
+ * - GATHER: source (swarm-mail|hive), duration_ms, stats/counts
+ * - DETECT: confidence, detected, reason_count, reasons
+ * - INJECT: confidence, context_length, context_type (full|fallback|none)
+ * - COMPLETE: duration_ms, success, detected, confidence, context_injected
+ */
+function getLog() {
+  if (!_logger) {
+    _logger = createChildLogger("compaction");
+  }
+  return _logger;
+}
 
 // ============================================================================
 // Compaction Context
@@ -145,6 +167,252 @@ Include this in your summary:
 "This is an active swarm. Check swarm_status and swarmmail_inbox immediately."
 `;
 
+// ============================================================================
+// Dynamic Context Building
+// ============================================================================
+
+/**
+ * Build dynamic swarm state section from detected state
+ * 
+ * This injects SPECIFIC values instead of placeholders, making the context
+ * immediately actionable on resume.
+ */
+function buildDynamicSwarmState(state: SwarmState): string {
+  const parts: string[] = [];
+  
+  parts.push("## 🐝 Current Swarm State\n");
+  
+  if (state.epicId && state.epicTitle) {
+    parts.push(`**Epic:** ${state.epicId} - ${state.epicTitle}`);
+    
+    const totalSubtasks = state.subtasks.closed + state.subtasks.in_progress + 
+                          state.subtasks.open + state.subtasks.blocked;
+    
+    if (totalSubtasks > 0) {
+      parts.push(`**Subtasks:**`);
+      if (state.subtasks.closed > 0) parts.push(`  - ${state.subtasks.closed} closed`);
+      if (state.subtasks.in_progress > 0) parts.push(`  - ${state.subtasks.in_progress} in_progress`);
+      if (state.subtasks.open > 0) parts.push(`  - ${state.subtasks.open} open`);
+      if (state.subtasks.blocked > 0) parts.push(`  - ${state.subtasks.blocked} blocked`);
+    }
+  }
+  
+  parts.push(`**Project:** ${state.projectPath}`);
+  
+  if (state.epicId) {
+    parts.push(`\n## 🎯 YOU ARE THE COORDINATOR`);
+    parts.push(``);
+    parts.push(`**Primary role:** Orchestrate workers, review their output, unblock dependencies.`);
+    parts.push(`**Spawn workers** for implementation tasks - don't do them yourself.`);
+    parts.push(``);
+    parts.push(`**RESUME STEPS:**`);
+    parts.push(`1. Check swarm status: \`swarm_status(epic_id="${state.epicId}", project_key="${state.projectPath}")\``);
+    parts.push(`2. Check inbox for worker messages: \`swarmmail_inbox(limit=5)\``);
+    parts.push(`3. For in_progress subtasks: Review worker results with \`swarm_review\``);
+    parts.push(`4. For open subtasks: Spawn workers with \`swarm_spawn_subtask\``);
+    parts.push(`5. For blocked subtasks: Investigate and unblock`);
+  }
+  
+  return parts.join("\n");
+}
+
+// ============================================================================
+// SDK Message Scanning
+// ============================================================================
+
+/**
+ * Tool part with completed state containing input/output
+ */
+interface ToolPart {
+  id: string;
+  sessionID: string;
+  messageID: string;
+  type: "tool";
+  callID: string;
+  tool: string;
+  state: ToolState;
+}
+
+/**
+ * Tool state (completed tools have input/output we need)
+ */
+type ToolState = {
+  status: "completed";
+  input: { [key: string]: unknown };
+  output: string;
+  title: string;
+  metadata: { [key: string]: unknown };
+  time: { start: number; end: number };
+} | {
+  status: string;
+  [key: string]: unknown;
+};
+
+/**
+ * SDK Client type (minimal interface for scanSessionMessages)
+ */
+interface OpencodeClient {
+  session: {
+    messages: (opts: { sessionID: string; limit?: number }) => Promise<{
+      info: { id: string; sessionID: string };
+      parts: ToolPart[];
+    }[]>;
+  };
+}
+
+/**
+ * Scanned swarm state extracted from session messages
+ */
+export interface ScannedSwarmState {
+  epicId?: string;
+  epicTitle?: string;
+  projectPath?: string;
+  agentName?: string;
+  subtasks: Map<string, { title: string; status: string; worker?: string; files?: string[] }>;
+  lastAction?: { tool: string; args: unknown; timestamp: number };
+}
+
+/**
+ * Scan session messages for swarm state using SDK client
+ * 
+ * Extracts swarm coordination state from actual tool calls:
+ * - swarm_spawn_subtask → subtask tracking
+ * - swarmmail_init → agent name, project path
+ * - hive_create_epic → epic ID and title
+ * - swarm_status → epic reference
+ * - swarm_complete → subtask completion
+ * 
+ * @param client - OpenCode SDK client (undefined if not available)
+ * @param sessionID - Session to scan
+ * @param limit - Max messages to fetch (default 100)
+ * @returns Extracted swarm state
+ */
+export async function scanSessionMessages(
+  client: OpencodeClient | undefined,
+  sessionID: string,
+  limit: number = 100
+): Promise<ScannedSwarmState> {
+  const state: ScannedSwarmState = {
+    subtasks: new Map(),
+  };
+
+  if (!client) {
+    return state;
+  }
+
+  try {
+    const messages = await client.session.messages({ sessionID, limit });
+
+    for (const message of messages) {
+      for (const part of message.parts) {
+        if (part.type !== "tool" || part.state.status !== "completed") {
+          continue;
+        }
+
+        const { tool, state: toolState } = part;
+        const { input, output, time } = toolState as Extract<ToolState, { status: "completed" }>;
+
+        // Track last action
+        state.lastAction = {
+          tool,
+          args: input,
+          timestamp: time.end,
+        };
+
+        // Extract swarm state based on tool type
+        switch (tool) {
+          case "hive_create_epic": {
+            try {
+              const parsed = JSON.parse(output);
+              if (parsed.epic?.id) {
+                state.epicId = parsed.epic.id;
+              }
+              if (input.epic_title && typeof input.epic_title === "string") {
+                state.epicTitle = input.epic_title;
+              }
+            } catch {
+              // Invalid JSON, skip
+            }
+            break;
+          }
+
+          case "swarmmail_init": {
+            try {
+              const parsed = JSON.parse(output);
+              if (parsed.agent_name) {
+                state.agentName = parsed.agent_name;
+              }
+              if (parsed.project_key) {
+                state.projectPath = parsed.project_key;
+              }
+            } catch {
+              // Invalid JSON, skip
+            }
+            break;
+          }
+
+          case "swarm_spawn_subtask": {
+            const beadId = input.bead_id as string | undefined;
+            const epicId = input.epic_id as string | undefined;
+            const title = input.subtask_title as string | undefined;
+            const files = input.files as string[] | undefined;
+
+            if (beadId && title) {
+              let worker: string | undefined;
+              try {
+                const parsed = JSON.parse(output);
+                worker = parsed.worker;
+              } catch {
+                // No worker in output
+              }
+
+              state.subtasks.set(beadId, {
+                title,
+                status: "spawned",
+                worker,
+                files,
+              });
+
+              if (epicId && !state.epicId) {
+                state.epicId = epicId;
+              }
+            }
+            break;
+          }
+
+          case "swarm_complete": {
+            const beadId = input.bead_id as string | undefined;
+            if (beadId && state.subtasks.has(beadId)) {
+              const existing = state.subtasks.get(beadId)!;
+              state.subtasks.set(beadId, {
+                ...existing,
+                status: "completed",
+              });
+            }
+            break;
+          }
+
+          case "swarm_status": {
+            const epicId = input.epic_id as string | undefined;
+            if (epicId && !state.epicId) {
+              state.epicId = epicId;
+            }
+            const projectKey = input.project_key as string | undefined;
+            if (projectKey && !state.projectPath) {
+              state.projectPath = projectKey;
+            }
+            break;
+          }
+        }
+      }
+    }
+  } catch (error) {
+    // SDK not available or error fetching messages - return what we have
+  }
+
+  return state;
+}
+
 // ============================================================================
 // Swarm Detection
 // ============================================================================
@@ -156,6 +424,23 @@ interface SwarmDetection {
   detected: boolean;
   confidence: "high" | "medium" | "low" | "none";
   reasons: string[];
+  /** Specific swarm state data for context injection */
+  state?: SwarmState;
+}
+
+/**
+ * Specific swarm state captured during detection
+ */
+interface SwarmState {
+  epicId?: string;
+  epicTitle?: string;
+  projectPath: string;
+  subtasks: {
+    closed: number;
+    in_progress: number;
+    open: number;
+    blocked: number;
+  };
 }
 
 /**
@@ -173,13 +458,38 @@ async function detectSwarm(): Promise<SwarmDetection> {
   let highConfidence = false;
   let mediumConfidence = false;
   let lowConfidence = false;
+  let state: SwarmState | undefined;
 
   try {
     const projectKey = getHiveWorkingDirectory();
+    
+    // Initialize state with project path
+    state = {
+      projectPath: projectKey,
+      subtasks: {
+        closed: 0,
+        in_progress: 0,
+        open: 0,
+        blocked: 0,
+      },
+    };
 
     // Check 1: Active reservations in swarm-mail (HIGH confidence)
+    const swarmMailStart = Date.now();
     try {
       const health = await checkSwarmHealth(projectKey);
+      const duration = Date.now() - swarmMailStart;
+
+      getLog().debug(
+        {
+          source: "swarm-mail",
+          duration_ms: duration,
+          healthy: health.healthy,
+          stats: health.stats,
+        },
+        "checked swarm-mail health",
+      );
+
       if (health.healthy && health.stats) {
         if (health.stats.reservations > 0) {
           highConfidence = true;
@@ -194,14 +504,24 @@ async function detectSwarm(): Promise<SwarmDetection> {
           reasons.push(`${health.stats.messages} swarm messages`);
         }
       }
-    } catch {
+    } catch (error) {
+      getLog().debug(
+        {
+          source: "swarm-mail",
+          duration_ms: Date.now() - swarmMailStart,
+          error: error instanceof Error ? error.message : String(error),
+        },
+        "swarm-mail check failed",
+      );
       // Swarm-mail not available, continue with other checks
     }
 
     // Check 2: Hive cells (various confidence levels)
+    const hiveStart = Date.now();
     try {
       const adapter = await getHiveAdapter(projectKey);
       const cells = await adapter.queryCells(projectKey, {});
+      const duration = Date.now() - hiveStart;
 
       if (Array.isArray(cells) && cells.length > 0) {
         // HIGH: Any in_progress cells
@@ -213,7 +533,7 @@ async function detectSwarm(): Promise<SwarmDetection> {
 
         // MEDIUM: Open subtasks (cells with parent_id)
         const subtasks = cells.filter(
-          (c) => c.status === "open" && c.parent_id
+          (c) => c.status === "open" && c.parent_id,
         );
         if (subtasks.length > 0) {
           mediumConfidence = true;
@@ -222,11 +542,37 @@ async function detectSwarm(): Promise<SwarmDetection> {
 
         // MEDIUM: Unclosed epics
         const openEpics = cells.filter(
-          (c) => c.type === "epic" && c.status !== "closed"
+          (c) => c.type === "epic" && c.status !== "closed",
         );
         if (openEpics.length > 0) {
           mediumConfidence = true;
           reasons.push(`${openEpics.length} unclosed epics`);
+          
+          // Capture in_progress epic data for state
+          const inProgressEpic = openEpics.find((c) => c.status === "in_progress");
+          if (inProgressEpic && state) {
+            state.epicId = inProgressEpic.id;
+            state.epicTitle = inProgressEpic.title;
+            
+            // Count subtasks for this epic
+            const epicSubtasks = cells.filter((c) => c.parent_id === inProgressEpic.id);
+            state.subtasks.closed = epicSubtasks.filter((c) => c.status === "closed").length;
+            state.subtasks.in_progress = epicSubtasks.filter((c) => c.status === "in_progress").length;
+            state.subtasks.open = epicSubtasks.filter((c) => c.status === "open").length;
+            state.subtasks.blocked = epicSubtasks.filter((c) => c.status === "blocked").length;
+            
+            getLog().debug(
+              {
+                epic_id: state.epicId,
+                epic_title: state.epicTitle,
+                subtasks_closed: state.subtasks.closed,
+                subtasks_in_progress: state.subtasks.in_progress,
+                subtasks_open: state.subtasks.open,
+                subtasks_blocked: state.subtasks.blocked,
+              },
+              "captured epic state for context",
+            );
+          }
         }
 
         // MEDIUM: Recently updated cells (last hour)
@@ -242,14 +588,46 @@ async function detectSwarm(): Promise<SwarmDetection> {
           lowConfidence = true;
           reasons.push(`${cells.length} total cells in hive`);
         }
+
+        getLog().debug(
+          {
+            source: "hive",
+            duration_ms: duration,
+            total_cells: cells.length,
+            in_progress: inProgress.length,
+            open_subtasks: subtasks.length,
+            open_epics: openEpics.length,
+            recent_updates: recentCells.length,
+          },
+          "checked hive cells",
+        );
+      } else {
+        getLog().debug(
+          { source: "hive", duration_ms: duration, total_cells: 0 },
+          "hive empty",
+        );
       }
-    } catch {
+    } catch (error) {
+      getLog().debug(
+        {
+          source: "hive",
+          duration_ms: Date.now() - hiveStart,
+          error: error instanceof Error ? error.message : String(error),
+        },
+        "hive check failed",
+      );
       // Hive not available, continue
     }
-  } catch {
+  } catch (error) {
     // Project detection failed, use fallback
     lowConfidence = true;
     reasons.push("Could not detect project, using fallback");
+    getLog().debug(
+      {
+        error: error instanceof Error ? error.message : String(error),
+      },
+      "project detection failed",
+    );
   }
 
   // Determine overall confidence
@@ -264,11 +642,25 @@ async function detectSwarm(): Promise<SwarmDetection> {
     confidence = "none";
   }
 
-  return {
+  const result = {
     detected: confidence !== "none",
     confidence,
     reasons,
+    state,
   };
+
+  getLog().debug(
+    {
+      detected: result.detected,
+      confidence: result.confidence,
+      reason_count: result.reasons.length,
+      reasons: result.reasons,
+      has_state: !!result.state,
+    },
+    "swarm detection complete",
+  );
+
+  return result;
 }
 
 // ============================================================================
@@ -298,20 +690,98 @@ async function detectSwarm(): Promise<SwarmDetection> {
  */
 export function createCompactionHook() {
   return async (
-    _input: { sessionID: string },
+    input: { sessionID: string },
     output: { context: string[] },
   ): Promise<void> => {
-    const detection = await detectSwarm();
-
-    if (detection.confidence === "high" || detection.confidence === "medium") {
-      // Definite or probable swarm - inject full context
-      const header = `[Swarm detected: ${detection.reasons.join(", ")}]\n\n`;
-      output.context.push(header + SWARM_COMPACTION_CONTEXT);
-    } else if (detection.confidence === "low") {
-      // Possible swarm - inject fallback detection prompt
-      const header = `[Possible swarm: ${detection.reasons.join(", ")}]\n\n`;
-      output.context.push(header + SWARM_DETECTION_FALLBACK);
+    const startTime = Date.now();
+
+    getLog().info(
+      {
+        session_id: input.sessionID,
+        trigger: "session_compaction",
+      },
+      "compaction started",
+    );
+
+    try {
+      const detection = await detectSwarm();
+
+      if (
+        detection.confidence === "high" ||
+        detection.confidence === "medium"
+      ) {
+        // Definite or probable swarm - inject full context
+        const header = `[Swarm detected: ${detection.reasons.join(", ")}]\n\n`;
+        
+        // Build dynamic state section if we have specific data
+        let dynamicState = "";
+        if (detection.state && detection.state.epicId) {
+          dynamicState = buildDynamicSwarmState(detection.state) + "\n\n";
+        }
+        
+        const contextContent = header + dynamicState + SWARM_COMPACTION_CONTEXT;
+        output.context.push(contextContent);
+
+        getLog().info(
+          {
+            confidence: detection.confidence,
+            context_length: contextContent.length,
+            context_type: "full",
+            reasons: detection.reasons,
+            has_dynamic_state: !!dynamicState,
+            epic_id: detection.state?.epicId,
+          },
+          "injected swarm context",
+        );
+      } else if (detection.confidence === "low") {
+        // Possible swarm - inject fallback detection prompt
+        const header = `[Possible swarm: ${detection.reasons.join(", ")}]\n\n`;
+        const contextContent = header + SWARM_DETECTION_FALLBACK;
+        output.context.push(contextContent);
+
+        getLog().info(
+          {
+            confidence: detection.confidence,
+            context_length: contextContent.length,
+            context_type: "fallback",
+            reasons: detection.reasons,
+          },
+          "injected swarm context",
+        );
+      } else {
+        getLog().debug(
+          {
+            confidence: detection.confidence,
+            context_type: "none",
+          },
+          "no swarm detected, skipping injection",
+        );
+      }
+      // confidence === "none" - no injection, probably not a swarm
+
+      const duration = Date.now() - startTime;
+      getLog().info(
+        {
+          duration_ms: duration,
+          success: true,
+          detected: detection.detected,
+          confidence: detection.confidence,
+          context_injected: output.context.length > 0,
+        },
+        "compaction complete",
+      );
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      getLog().error(
+        {
+          duration_ms: duration,
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined,
+        },
+        "compaction failed",
+      );
+      // Don't throw - compaction hook failures shouldn't break the session
     }
-    // confidence === "none" - no injection, probably not a swarm
   };
 }

package/src/index.ts

@@ -684,6 +684,35 @@ export {
 } from "./memory-tools";
 export type { Memory, SearchResult, SearchOptions } from "swarm-mail";
 
+/**
+ * Re-export logger infrastructure
+ *
+ * Includes:
+ * - getLogger - Gets or creates the main logger instance
+ * - createChildLogger - Creates a module-specific child logger with separate log file
+ * - logger - Default logger instance for immediate use
+ *
+ * Features:
+ * - Daily log rotation via pino-roll (numeric format: swarm.1log, swarm.2log, etc.)
+ * - 14-day retention
+ * - Module-specific child loggers
+ * - Pretty mode for development (SWARM_LOG_PRETTY=1)
+ * - Logs to ~/.config/swarm-tools/logs/
+ *
+ * @example
+ * ```typescript
+ * import { logger, createChildLogger } from "opencode-swarm-plugin";
+ *
+ * // Use default logger
+ * logger.info("Application started");
+ *
+ * // Create module-specific logger
+ * const compactionLog = createChildLogger("compaction");
+ * compactionLog.info("Compaction started");
+ * ```
+ */
+export { getLogger, createChildLogger, logger } from "./logger";
+
 /**
  * Re-export swarm-research module
  *