opencode-swarm-plugin 0.42.9 → 0.43.0

package/bin/swarm.ts

@@ -2503,6 +2503,405 @@ async function update() {
   }
 }
 
+// ============================================================================
+// Observability Commands (Phase 5)
+// ============================================================================
+
+/**
+ * Parse args for query command
+ */
+function parseQueryArgs(args: string[]): { format: string; query?: string; preset?: string } {
+  let format = "table";
+  let query: string | undefined;
+  let preset: string | undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--format") {
+      format = args[i + 1] || "table";
+      i++;
+    } else if (args[i] === "--sql") {
+      query = args[i + 1];
+      i++;
+    } else if (args[i] === "--preset") {
+      preset = args[i + 1];
+      i++;
+    }
+  }
+
+  return { format, query, preset };
+}
+
+async function query() {
+  const args = process.argv.slice(3); // Everything after "swarm query"
+  const parsed = parseQueryArgs(args);
+
+  // Import query tools
+  const { executeQuery, executePreset, formatAsTable, formatAsCSV, formatAsJSON } = await import("../src/observability/query-tools.js");
+
+  p.intro("swarm query");
+
+  const projectPath = process.cwd();
+
+  try {
+    let rows: any[];
+
+    if (parsed.preset) {
+      // Execute preset query
+      p.log.step(`Executing preset: ${parsed.preset}`);
+      rows = await executePreset(projectPath, parsed.preset);
+    } else if (parsed.query) {
+      // Execute custom SQL
+      p.log.step("Executing custom SQL");
+      rows = await executeQuery(projectPath, parsed.query);
+    } else {
+      p.log.error("No query specified. Use --sql or --preset");
+      p.outro("Aborted");
+      process.exit(1);
+    }
+
+    // Format output
+    let output: string;
+    switch (parsed.format) {
+      case "csv":
+        output = formatAsCSV(rows);
+        break;
+      case "json":
+        output = formatAsJSON(rows);
+        break;
+      case "table":
+      default:
+        output = formatAsTable(rows);
+        break;
+    }
+
+    console.log();
+    console.log(output);
+    console.log();
+
+    p.outro(`Found ${rows.length} result(s)`);
+  } catch (error) {
+    p.log.error("Query failed");
+    p.log.message(error instanceof Error ? error.message : String(error));
+    p.outro("Aborted");
+    process.exit(1);
+  }
+}
+
+/**
+ * Parse args for dashboard command
+ */
+function parseDashboardArgs(args: string[]): { epic?: string; refresh: number } {
+  let epic: string | undefined;
+  let refresh = 1000;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--epic") {
+      epic = args[i + 1];
+      i++;
+    } else if (args[i] === "--refresh") {
+      const ms = parseInt(args[i + 1], 10);
+      if (!isNaN(ms) && ms > 0) {
+        refresh = ms;
+      }
+      i++;
+    }
+  }
+
+  return { epic, refresh };
+}
+
+async function dashboard() {
+  const args = process.argv.slice(3);
+  const parsed = parseDashboardArgs(args);
+
+  const { getWorkerStatus, getSubtaskProgress, getFileLocks, getRecentMessages, getEpicList } = await import("../src/observability/dashboard.js");
+
+  p.intro("swarm dashboard");
+
+  const projectPath = process.cwd();
+
+  console.clear();
+  console.log(yellow("=".repeat(60)));
+  console.log(yellow("  SWARM DASHBOARD"));
+  console.log(yellow("=".repeat(60)));
+  console.log();
+
+  let iteration = 0;
+
+  // Refresh loop
+  const refreshLoop = async () => {
+    try {
+      // Move cursor to top
+      if (iteration > 0) {
+        process.stdout.write("\x1b[H");
+      }
+
+      const timestamp = new Date().toLocaleTimeString();
+      console.log(dim(`Last updated: ${timestamp} (Press Ctrl+C to exit)`));
+      console.log();
+
+      // Worker Status
+      console.log(cyan("Worker Status:"));
+      const workers = await getWorkerStatus(projectPath, parsed.epic);
+      if (workers.length === 0) {
+        console.log(dim("  No active workers"));
+      } else {
+        for (const w of workers) {
+          console.log(`  ${w.agent_name} - ${w.status} - ${w.current_bead_id || "idle"}`);
+        }
+      }
+      console.log();
+
+      // Subtask Progress
+      console.log(cyan("Subtask Progress:"));
+      const progress = await getSubtaskProgress(projectPath, parsed.epic);
+      if (progress.length === 0) {
+        console.log(dim("  No subtasks"));
+      } else {
+        for (const p of progress) {
+          const bar = "█".repeat(Math.floor(p.progress / 10)) + "░".repeat(10 - Math.floor(p.progress / 10));
+          console.log(`  ${p.bead_id} [${bar}] ${p.progress}% - ${p.status}`);
+        }
+      }
+      console.log();
+
+      // File Locks
+      console.log(cyan("File Locks:"));
+      const locks = await getFileLocks(projectPath);
+      if (locks.length === 0) {
+        console.log(dim("  No active locks"));
+      } else {
+        for (const lock of locks) {
+          console.log(`  ${lock.path_pattern} - ${lock.agent_name} (${lock.exclusive ? "exclusive" : "shared"})`);
+        }
+      }
+      console.log();
+
+      // Recent Messages
+      console.log(cyan("Recent Messages:"));
+      const messages = await getRecentMessages(projectPath, parsed.epic, 5);
+      if (messages.length === 0) {
+        console.log(dim("  No recent messages"));
+      } else {
+        for (const msg of messages) {
+          const timeAgo = Math.floor((Date.now() - new Date(msg.timestamp).getTime()) / 1000);
+          console.log(`  ${msg.from_agent} → ${msg.to_agents}: ${msg.subject} (${timeAgo}s ago)`);
+        }
+      }
+      console.log();
+
+      iteration++;
+    } catch (error) {
+      console.log(red("Dashboard error: " + (error instanceof Error ? error.message : String(error))));
+    }
+  };
+
+  // Initial render
+  await refreshLoop();
+
+  // Set up refresh interval
+  const interval = setInterval(refreshLoop, parsed.refresh);
+
+  // Handle Ctrl+C
+  process.on("SIGINT", () => {
+    clearInterval(interval);
+    console.log();
+    p.outro("Dashboard closed");
+    process.exit(0);
+  });
+
+  // Keep process alive
+  await new Promise(() => {});
+}
+
+/**
+ * Parse args for replay command
+ */
+function parseReplayArgs(args: string[]): {
+  epicId?: string;
+  speed: number;
+  types: string[];
+  agent?: string;
+  since?: Date;
+  until?: Date;
+} {
+  let epicId: string | undefined;
+  let speed = 1;
+  let types: string[] = [];
+  let agent: string | undefined;
+  let since: Date | undefined;
+  let until: Date | undefined;
+
+  // First positional arg is epic ID
+  if (args.length > 0 && !args[0].startsWith("--")) {
+    epicId = args[0];
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--speed") {
+      const val = args[i + 1];
+      if (val === "instant") {
+        speed = Infinity;
+      } else {
+        const parsed = parseFloat(val?.replace("x", "") || "1");
+        if (!isNaN(parsed) && parsed > 0) {
+          speed = parsed;
+        }
+      }
+      i++;
+    } else if (args[i] === "--type") {
+      types = args[i + 1]?.split(",").map((t) => t.trim()) || [];
+      i++;
+    } else if (args[i] === "--agent") {
+      agent = args[i + 1];
+      i++;
+    } else if (args[i] === "--since") {
+      const dateStr = args[i + 1];
+      if (dateStr) {
+        since = new Date(dateStr);
+      }
+      i++;
+    } else if (args[i] === "--until") {
+      const dateStr = args[i + 1];
+      if (dateStr) {
+        until = new Date(dateStr);
+      }
+      i++;
+    }
+  }
+
+  return { epicId, speed, types, agent, since, until };
+}
+
+async function replay() {
+  const args = process.argv.slice(3);
+  const parsed = parseReplayArgs(args);
+
+  if (!parsed.epicId) {
+    p.log.error("Epic ID required");
+    p.log.message("Usage: swarm replay <epic-id> [options]");
+    process.exit(1);
+  }
+
+  const { fetchEpicEvents, filterEvents, replayWithTiming, formatReplayEvent } = await import("../src/observability/replay-tools.js");
+
+  p.intro(`swarm replay ${parsed.epicId}`);
+
+  const projectPath = process.cwd();
+
+  try {
+    // Fetch events
+    p.log.step("Fetching events...");
+    let events = await fetchEpicEvents(projectPath, parsed.epicId);
+
+    // Apply filters
+    events = filterEvents(events, {
+      types: parsed.types,
+      agent: parsed.agent,
+      since: parsed.since,
+      until: parsed.until,
+    });
+
+    if (events.length === 0) {
+      p.log.warn("No events found matching filters");
+      p.outro("Aborted");
+      process.exit(0);
+    }
+
+    p.log.success(`Found ${events.length} events`);
+    p.log.message(dim(`Speed: ${parsed.speed === Infinity ? "instant" : `${parsed.speed}x`}`));
+    console.log();
+
+    // Replay events
+    await replayWithTiming(events, parsed.speed, (event) => {
+      console.log(formatReplayEvent(event));
+    });
+
+    console.log();
+    p.outro("Replay complete");
+  } catch (error) {
+    p.log.error("Replay failed");
+    p.log.message(error instanceof Error ? error.message : String(error));
+    p.outro("Aborted");
+    process.exit(1);
+  }
+}
+
+/**
+ * Parse args for export command
+ */
+function parseExportArgs(args: string[]): {
+  format: string;
+  epic?: string;
+  output?: string;
+} {
+  let format = "json";
+  let epic: string | undefined;
+  let output: string | undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--format") {
+      format = args[i + 1] || "json";
+      i++;
+    } else if (args[i] === "--epic") {
+      epic = args[i + 1];
+      i++;
+    } else if (args[i] === "--output") {
+      output = args[i + 1];
+      i++;
+    }
+  }
+
+  return { format, epic, output };
+}
+
+async function exportEvents() {
+  const args = process.argv.slice(3);
+  const parsed = parseExportArgs(args);
+
+  const { exportToOTLP, exportToCSV, exportToJSON } = await import("../src/observability/export-tools.js");
+
+  p.intro("swarm export");
+
+  const projectPath = process.cwd();
+
+  try {
+    let result: string;
+
+    p.log.step(`Exporting as ${parsed.format}...`);
+
+    switch (parsed.format) {
+      case "otlp":
+        result = await exportToOTLP(projectPath, parsed.epic);
+        break;
+      case "csv":
+        result = await exportToCSV(projectPath, parsed.epic);
+        break;
+      case "json":
+      default:
+        result = await exportToJSON(projectPath, parsed.epic);
+        break;
+    }
+
+    // Output to file or stdout
+    if (parsed.output) {
+      writeFileSync(parsed.output, result);
+      p.log.success(`Exported to: ${parsed.output}`);
+    } else {
+      console.log();
+      console.log(result);
+      console.log();
+    }
+
+    p.outro("Export complete");
+  } catch (error) {
+    p.log.error("Export failed");
+    p.log.message(error instanceof Error ? error.message : String(error));
+    p.outro("Aborted");
+    process.exit(1);
+  }
+}
+
 async function help() {
   console.log(yellow(BANNER));
   console.log(dim("  " + TAGLINE + " v" + VERSION));
@@ -2525,6 +2924,10 @@ ${cyan("Commands:")}
   swarm stats     Show swarm health metrics powered by swarm-insights (strategy success rates, patterns)
   swarm history   Show recent swarm activity timeline with insights data
   swarm eval      Eval-driven development commands
+  swarm query     SQL analytics with presets (--sql, --preset, --format)
+  swarm dashboard Live terminal UI with worker status (--epic, --refresh)
+  swarm replay    Event replay with timing (--speed, --type, --agent, --since, --until)
+  swarm export    Export events (--format otlp/csv/json, --epic, --output)
   swarm update    Update to latest version
   swarm version   Show version and banner
   swarm tool      Execute a tool (for plugin wrapper)
@@ -2573,6 +2976,25 @@ ${cyan("Eval Commands:")}
   swarm eval history                   Show eval run history with trends
   swarm eval run                       Execute evals and report results (stub)
 
+${cyan("Observability Commands:")}
+  swarm query --sql <query>            Execute custom SQL query
+  swarm query --preset <name>          Execute preset query (failed_decompositions, duration_by_strategy, etc)
+  swarm query --format <fmt>           Output format: table (default), csv, json
+  swarm dashboard                      Live terminal UI showing worker status, progress, locks, messages
+  swarm dashboard --epic <id>          Focus on specific epic
+  swarm dashboard --refresh <ms>       Poll interval in milliseconds (default: 1000)
+  swarm replay <epic-id>               Replay epic events with timing
+  swarm replay <epic-id> --speed 2x    Playback speed: 1x, 2x, instant
+  swarm replay <epic-id> --type <types>  Filter by event types (comma-separated)
+  swarm replay <epic-id> --agent <name>  Filter by agent name
+  swarm replay <epic-id> --since <time>  Events after this time
+  swarm replay <epic-id> --until <time>  Events before this time
+  swarm export                         Export events to stdout (JSON)
+  swarm export --format otlp           Export as OpenTelemetry (OTLP)
+  swarm export --format csv            Export as CSV
+  swarm export --epic <id>             Export specific epic only
+  swarm export --output <file>         Write to file instead of stdout
+
 ${cyan("Usage in OpenCode:")}
   /swarm "Add user authentication with OAuth"
   @swarm/planner "Decompose this into parallel tasks"
@@ -4612,6 +5034,18 @@ switch (command) {
   case "eval":
     await evalCommand();
     break;
+  case "query":
+    await query();
+    break;
+  case "dashboard":
+    await dashboard();
+    break;
+  case "replay":
+    await replay();
+    break;
+  case "export":
+    await exportEvents();
+    break;
   case "version":
   case "--version":
   case "-v":

package/dist/dashboard.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Dashboard Data Layer
+ *
+ * Provides read-only queries for swarm observability dashboard.
+ * Data sources:
+ * - libSQL events table (event sourcing)
+ * - Hive cells (work items)
+ * - Agent projections (agent states)
+ * - Reservation projections (file locks)
+ */
+import type { DatabaseAdapter } from "swarm-mail";
+export interface WorkerStatus {
+    agent_name: string;
+    status: "idle" | "working" | "blocked";
+    current_task?: string;
+    last_activity: string;
+}
+export interface SubtaskProgress {
+    bead_id: string;
+    title: string;
+    status: "open" | "in_progress" | "completed" | "blocked";
+    progress_percent: number;
+}
+export interface FileLock {
+    path: string;
+    agent_name: string;
+    reason: string;
+    acquired_at: string;
+    ttl_seconds: number;
+}
+export interface RecentMessage {
+    id: number;
+    from: string;
+    to: string[];
+    subject: string;
+    timestamp: string;
+    importance: "low" | "normal" | "high" | "urgent";
+}
+export interface EpicInfo {
+    epic_id: string;
+    title: string;
+    subtask_count: number;
+    completed_count: number;
+}
+/**
+ * Get current status of all worker agents.
+ * Derives status from latest events: task_started, progress_reported, task_blocked, etc.
+ */
+export declare function getWorkerStatus(db: DatabaseAdapter, options?: {
+    project_key?: string;
+}): Promise<WorkerStatus[]>;
+/**
+ * Get progress of all subtasks within an epic.
+ * Returns completion percentage from progress_reported events.
+ */
+export declare function getSubtaskProgress(db: DatabaseAdapter, epic_id: string): Promise<SubtaskProgress[]>;
+/**
+ * Get currently active file reservations.
+ * Excludes released reservations.
+ */
+export declare function getFileLocks(db: DatabaseAdapter, options?: {
+    project_key?: string;
+}): Promise<FileLock[]>;
+/**
+ * Get recent swarm mail messages, ordered by timestamp descending.
+ * Defaults to limit of 10.
+ */
+export declare function getRecentMessages(db: DatabaseAdapter, options?: {
+    limit?: number;
+    thread_id?: string;
+    importance?: "low" | "normal" | "high" | "urgent";
+}): Promise<RecentMessage[]>;
+/**
+ * Get list of all epics with subtask counts.
+ * Used for dashboard tabs/navigation.
+ *
+ * Derives epic information from events when beads table doesn't exist (test mode).
+ * In production, queries beads table directly.
+ */
+export declare function getEpicList(db: DatabaseAdapter, options?: {
+    status?: "open" | "in_progress" | "completed" | "blocked";
+}): Promise<EpicInfo[]>;
+//# sourceMappingURL=dashboard.d.ts.map

package/dist/dashboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard.d.ts","sourceRoot":"","sources":["../src/dashboard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,MAAM,WAAW,YAAY;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,WAAW,GAAG,SAAS,CAAC;IACzD,gBAAgB,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,QAAQ;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,CAAC;CACjD;AAED,MAAM,WAAW,QAAQ;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACpC,EAAE,EAAE,eAAe,EACnB,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAChC,OAAO,CAAC,YAAY,EAAE,CAAC,CAoEzB;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACvC,EAAE,EAAE,eAAe,EACnB,OAAO,EAAE,MAAM,GACb,OAAO,CAAC,eAAe,EAAE,CAAC,CAuD5B;AAED;;;GAGG;AACH,wBAAsB,YAAY,CACjC,EAAE,EAAE,eAAe,EACnB,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAChC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAiDrB;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACtC,EAAE,EAAE,eAAe,EACnB,OAAO,CAAC,EAAE;IACT,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,CAAC;CAClD,GACC,OAAO,CAAC,aAAa,EAAE,CAAC,CAkD1B;AAED;;;;;;GAMG;AACH,wBAAsB,WAAW,CAChC,EAAE,EAAE,eAAe,EACnB,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,WAAW,GAAG,SAAS,CAAA;CAAE,GACrE,OAAO,CAAC,QAAQ,EAAE,CAAC,CA0IrB"}

package/dist/error-enrichment.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Error Enrichment - Structured error context for swarm agents
+ *
+ * TDD GREEN: Minimal implementation to pass tests
+ */
+export interface SwarmErrorContext {
+    file?: string;
+    line?: number;
+    agent?: string;
+    epic_id?: string;
+    bead_id?: string;
+    recent_events?: Array<{
+        type: string;
+        timestamp: string;
+        message: string;
+    }>;
+}
+/**
+ * SwarmError - Error class with structured context
+ */
+export declare class SwarmError extends Error {
+    context: SwarmErrorContext;
+    constructor(message: string, context?: SwarmErrorContext);
+    toJSON(): {
+        name: string;
+        message: string;
+        context: SwarmErrorContext;
+        stack: string | undefined;
+    };
+}
+/**
+ * enrichError - Convert any error to SwarmError with context
+ */
+export declare function enrichError(error: unknown, context: SwarmErrorContext): SwarmError;
+/**
+ * debugLog - Conditional logging based on DEBUG env var
+ *
+ * Patterns:
+ * - DEBUG=swarm:* (all)
+ * - DEBUG=swarm:coordinator
+ * - DEBUG=swarm:worker
+ * - DEBUG=swarm:mail
+ */
+export declare function debugLog(namespace: string, message: string, data?: unknown): void;
+/**
+ * suggestFix - Pattern matching for common swarm errors
+ */
+export declare function suggestFix(error: Error | SwarmError): string | null;
+//# sourceMappingURL=error-enrichment.d.ts.map

package/dist/error-enrichment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-enrichment.d.ts","sourceRoot":"","sources":["../src/error-enrichment.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,iBAAiB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,KAAK,CAAC;QACrB,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;CACH;AAED;;GAEG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACpC,OAAO,EAAE,iBAAiB,CAAC;gBAEf,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB;IAW5D,MAAM;;;;;;CAQN;AAED;;GAEG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,iBAAiB,GACxB,UAAU,CAyBZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CACvB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,OAAO,GACZ,IAAI,CAyBN;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,GAAG,MAAM,GAAG,IAAI,CA8EnE"}

package/dist/export-tools.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Export Tools - Convert Cell Events to Various Formats
+ *
+ * GREEN PHASE: Minimal implementation to pass tests
+ *
+ * Supports:
+ * - OTLP (OpenTelemetry Protocol) - for distributed tracing
+ * - CSV - for spreadsheet analysis
+ * - JSON - for generic data interchange
+ */
+import type { CellEvent } from "./schemas/cell-events.js";
+/**
+ * OpenTelemetry OTLP span structure
+ */
+interface OTLPSpan {
+    traceId: string;
+    spanId: string;
+    name: string;
+    startTimeUnixNano: string;
+    attributes: Array<{
+        key: string;
+        value: {
+            stringValue?: string;
+            intValue?: number;
+            boolValue?: boolean;
+        };
+    }>;
+}
+interface OTLPOutput {
+    resourceSpans: Array<{
+        resource: {
+            attributes: Array<{
+                key: string;
+                value: {
+                    stringValue: string;
+                };
+            }>;
+        };
+        scopeSpans: Array<{
+            scope: {
+                name: string;
+            };
+            spans: OTLPSpan[];
+        }>;
+    }>;
+}
+/**
+ * Export cell events to OpenTelemetry OTLP format
+ *
+ * Mapping:
+ * - epic_id (from metadata) → trace_id (32 hex chars)
+ * - cell_id → span_id (16 hex chars)
+ * - timestamp → startTimeUnixNano (nanoseconds as string)
+ * - event.type → span.name
+ * - event payload → span.attributes
+ */
+export declare function exportToOTLP(events: CellEvent[]): OTLPOutput;
+/**
+ * Export cell events to CSV format
+ *
+ * Format:
+ * - Headers: id,type,timestamp,project_key,cell_id,payload
+ * - Payload: JSON serialization of entire event (minus headers)
+ */
+export declare function exportToCSV(events: CellEvent[]): string;
+/**
+ * Export cell events to JSON format
+ *
+ * Format:
+ * - Array of event objects
+ * - Pretty-printed with 2-space indentation
+ * - Preserves all fields and discriminated union types
+ */
+export declare function exportToJSON(events: CellEvent[]): string;
+export {};
+//# sourceMappingURL=export-tools.d.ts.map

package/dist/export-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-tools.d.ts","sourceRoot":"","sources":["../src/export-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAO1D;;GAEG;AACH,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,KAAK,CAAC;QAChB,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE;YACL,WAAW,CAAC,EAAE,MAAM,CAAC;YACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;YAClB,SAAS,CAAC,EAAE,OAAO,CAAC;SACrB,CAAC;KACH,CAAC,CAAC;CACJ;AAED,UAAU,UAAU;IAClB,aAAa,EAAE,KAAK,CAAC;QACnB,QAAQ,EAAE;YACR,UAAU,EAAE,KAAK,CAAC;gBAChB,GAAG,EAAE,MAAM,CAAC;gBACZ,KAAK,EAAE;oBAAE,WAAW,EAAE,MAAM,CAAA;iBAAE,CAAC;aAChC,CAAC,CAAC;SACJ,CAAC;QACF,UAAU,EAAE,KAAK,CAAC;YAChB,KAAK,EAAE;gBACL,IAAI,EAAE,MAAM,CAAC;aACd,CAAC;YACF,KAAK,EAAE,QAAQ,EAAE,CAAC;SACnB,CAAC,CAAC;KACJ,CAAC,CAAC;CACJ;AA6ED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,UAAU,CAiD5D;AAsBD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,CAoBvD;AAMD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,CAMxD"}

package/dist/index.d.ts

@@ -171,13 +171,13 @@ export declare const allTools: {
         args: {
             sql: import("zod").ZodString;
             format: import("zod").ZodOptional<import("zod").ZodEnum<{
-                json: "json";
                 table: "table";
+                json: "json";
             }>>;
         };
         execute(args: {
             sql: string;
-            format?: "json" | "table" | undefined;
+            format?: "table" | "json" | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
     readonly swarm_diagnose: {