@johpaz/hive-sdk 0.0.14 → 0.0.16

package/packages/core/src/swarm/Coordinator.ts

@@ -0,0 +1,251 @@
+/**
+ * DAGScheduler — Main orchestrator
+ *
+ * Executes a TaskGraph by:
+ *   1. Identifying all nodes with no dependencies → mark READY
+ *   2. Launching them concurrently via AgentExecutor (respecting maxConcurrentWorkers)
+ *   3. When a node completes, finding newly unblocked nodes and launching them
+ *   4. Propagating failures to dependent nodes
+ *   5. Emitting progress via EventBridge → agentBus + canvas
+ *
+ * Parallelism model: Promise.race() over a Set of active promises + a FIFO/priority
+ * queue of READY nodes waiting for a slot. No Bun Worker threads — workers are async
+ * agent calls (runAgentIsolated) running concurrently in the same process.
+ */
+
+import { writeFileSync, mkdirSync, existsSync } from "node:fs"
+import * as path from "node:path"
+import { logger } from "../utils/logger.ts"
+import { TaskGraph } from "./TaskGraph"
+import { TaskNode } from "./TaskNode"
+import { AgentExecutor } from "./AgentExecutor"
+import { EventBridge } from "./EventBridge"
+import { TaskFailureError } from "./errors"
+import type { DAGResult, NodeSummary } from "./TaskResult"
+import type { ExecutionStrategy } from "./strategies/ParallelStrategy"
+import { ParallelStrategy } from "./strategies/ParallelStrategy"
+
+const log = logger.child("dag-scheduler")
+
+export interface IAgentExecutor {
+  execute(node: TaskNode, depResults: Record<string, string>, threadId: string): Promise<string>
+}
+
+export interface DAGSchedulerOptions {
+  strategy?: ExecutionStrategy
+  maxConcurrentWorkers?: number
+  /** Project ID for agentBus/canvas events */
+  projectId?: string
+  /** Coordinator agent ID for agentBus events */
+  coordinatorId?: string
+  /** Disables ASCII log and file logging. Default: false in development */
+  silent?: boolean
+  /** Custom executor — defaults to AgentExecutor (runAgentIsolated). Override to bypass context-compiler. */
+  executor?: IAgentExecutor
+}
+
+export class DAGScheduler {
+  private strategy: ExecutionStrategy
+  private maxConcurrentWorkers: number
+  private executor: IAgentExecutor
+  private aborted = false
+
+  constructor(options: DAGSchedulerOptions = {}) {
+    this.strategy = options.strategy ?? new ParallelStrategy()
+    this.maxConcurrentWorkers = options.maxConcurrentWorkers ?? 2
+    this.executor = options.executor ?? new AgentExecutor()
+  }
+
+  abort(): void {
+    this.aborted = true
+  }
+
+  async execute(graph: TaskGraph, options: DAGSchedulerOptions = {}): Promise<DAGResult> {
+    this.aborted = false
+    const swarmId = crypto.randomUUID()
+    const startedAt = Date.now()
+
+    const projectId = options.projectId ?? `swarm:${swarmId}`
+    const coordinatorId = options.coordinatorId ?? "dag-scheduler"
+    const silent = options.silent ?? (process.env.NODE_ENV === "production")
+    const executor = options.executor ?? this.executor
+
+    const bridge = new EventBridge(swarmId, projectId, coordinatorId)
+
+    // Allow strategy to precompute (e.g. critical path)
+    if (this.strategy.initialize) {
+      this.strategy.initialize(graph.nodes)
+    }
+
+    bridge.onSwarmStarted(graph.nodes.size)
+    this.logState(swarmId, graph, startedAt, silent, swarmId)
+
+    // Seed the READY queue with nodes that have no dependencies
+    const readyQueue: TaskNode[] = []
+    const completedIds = graph.getCompletedIds()
+
+    for (const node of graph.nodes.values()) {
+      if (node.deps.length === 0) {
+        node.markReady()
+        readyQueue.push(node)
+      }
+    }
+
+    // Active promise set — we track them with a wrapper so we can drain
+    const running = new Set<Promise<void>>()
+
+    const launchNode = (node: TaskNode): void => {
+      if (this.aborted) return
+
+      node.markRunning()
+      bridge.onTaskStarted(node)
+      this.logState(swarmId, graph, startedAt, silent, swarmId)
+
+      const depResults = graph.getDepResults(node.id)
+      const threadId = `dag-${swarmId}-${node.id}`
+
+      const p: Promise<void> = executor
+        .execute(node, depResults, threadId)
+        .then(result => {
+          node.markCompleted(result)
+          log.info(`[DAG] ${node.name} COMPLETED in ${node.elapsedSeconds()}s`)
+          bridge.onTaskCompleted(node, graph.getProgress())
+          this.logState(swarmId, graph, startedAt, silent, swarmId)
+
+          // Unlock dependent nodes
+          const newlyReady = graph.getNewlyReadyNodes(graph.getCompletedIds())
+          for (const n of newlyReady) {
+            n.markReady()
+            readyQueue.push(n)
+          }
+        })
+        .catch(err => {
+          const error = err instanceof Error ? err.message : String(err)
+
+          if (node.canRetry()) {
+            node.retryCount++
+            log.warn(`[DAG] ${node.name} failed (retry ${node.retryCount}/${node.maxRetries}): ${error}`)
+            node.status = "PENDING"
+            node.markReady()
+            readyQueue.push(node)
+          } else {
+            node.markFailed(error)
+            log.error(`[DAG] ${node.name} FAILED permanently: ${error}`)
+            bridge.onTaskFailed(node, graph.getProgress())
+            graph.propagateFailure(node.id, error)
+            this.logState(swarmId, graph, startedAt, silent, swarmId)
+          }
+        })
+        .finally(() => {
+          running.delete(p)
+          drain()
+        })
+
+      running.add(p)
+    }
+
+    // Drain the ready queue into available worker slots
+    const drain = (): void => {
+      while (readyQueue.length > 0 && running.size < this.maxConcurrentWorkers && !this.aborted) {
+        const node = this.strategy.pick(readyQueue)
+        if (!node) break
+        launchNode(node)
+      }
+    }
+
+    // Start initial drain
+    drain()
+
+    // Wait until the graph is complete
+    while (!graph.isComplete() && !this.aborted) {
+      if (running.size === 0 && readyQueue.length === 0) {
+        // Deadlock guard: no running, nothing ready, but graph not done
+        // This can happen if all remaining nodes are FAILED
+        break
+      }
+      // Wait for any active promise to settle
+      if (running.size > 0) {
+        await Promise.race([...running])
+        drain()
+      } else {
+        // Brief yield to let microtasks settle
+        await new Promise(resolve => setTimeout(resolve, 10))
+      }
+    }
+
+    // Collect results
+    const completed: NodeSummary[] = []
+    const failed: NodeSummary[] = []
+
+    for (const node of graph.nodes.values()) {
+      const summary: NodeSummary = {
+        id: node.id,
+        name: node.name,
+        status: node.status === "COMPLETED" ? "COMPLETED" : "FAILED",
+        durationMs: node.startedAt ? (node.completedAt ?? Date.now()) - node.startedAt : 0,
+        result: node.result,
+        error: node.error,
+        retries: node.retryCount,
+      }
+      if (node.status === "COMPLETED") completed.push(summary)
+      else failed.push(summary)
+    }
+
+    const result: DAGResult = {
+      swarmId,
+      totalDurationMs: Date.now() - startedAt,
+      completed,
+      failed,
+      success: failed.length === 0,
+    }
+
+    bridge.onSwarmCompleted(result)
+    this.logState(swarmId, graph, startedAt, silent, swarmId)
+
+    log.info(`[DAG] swarm ${swarmId} finished. ${completed.length} completed, ${failed.length} failed. Total: ${Math.round(result.totalDurationMs / 1000)}s`)
+
+    return result
+  }
+
+  // ─── ASCII log ───────────────────────────────────────────────────────────────
+
+  private logState(
+    swarmId: string,
+    graph: TaskGraph,
+    startedAt: number,
+    silent: boolean,
+    sessionId: string
+  ): void {
+    const elapsed = Math.round((Date.now() - startedAt) / 1000)
+    const lines: string[] = [`[DAG] swarm:${swarmId.slice(0, 8)} T+${elapsed}s`]
+
+    for (const node of graph.nodes.values()) {
+      const icon =
+        node.status === "COMPLETED" ? "✓" :
+        node.status === "FAILED"    ? "✗" :
+        node.status === "RUNNING"   ? "●" : "○"
+
+      const depStr = node.deps.length > 0 ? `  (deps: ${node.deps.join(", ")})` : ""
+      const timeStr = node.startedAt ? `  (${node.elapsedSeconds()}s)` : ""
+      const statusLabel = node.status.padEnd(10)
+
+      lines.push(`  ${icon} ${node.name.padEnd(24)} ${statusLabel}${timeStr}${depStr}`)
+    }
+
+    const output = lines.join("\n")
+
+    if (!silent) {
+      // Write to log file (never committed — in .gitignore)
+      try {
+        const logDir = path.join(process.cwd(), "packages", "core", "logs")
+        if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true })
+        const logFile = path.join(logDir, `dag-${sessionId.slice(0, 8)}.log`)
+        writeFileSync(logFile, output + "\n\n", { flag: "a" })
+      } catch {
+        // Non-critical — never throw for logging
+      }
+    }
+
+    log.debug(output)
+  }
+}

package/packages/core/src/swarm/EventBridge.ts

@@ -0,0 +1,122 @@
+/**
+ * DAGScheduler — EventBridge
+ *
+ * Maps DAG lifecycle events to the existing agentBus so that the rest of
+ * Hive OSS can observe swarm progress without coupling to DAGScheduler directly.
+ *
+ * Also emits canvas:node_update events so the UI reflects task state in real time.
+ */
+
+import { agentBus } from "../swarm/AgentBus.ts"
+import { emitCanvas } from "../canvas/emitter.ts"
+import { TaskNode } from "./TaskNode"
+import { DAGResult } from "./TaskResult"
+
+const STATUS_TO_CANVAS: Record<string, string> = {
+  RUNNING: "thinking",
+  COMPLETED: "idle",
+  FAILED: "error",
+}
+
+export class EventBridge {
+  private swarmId: string
+  private projectId: string
+  private coordinatorId: string
+
+  constructor(swarmId: string, projectId: string, coordinatorId: string) {
+    this.swarmId = swarmId
+    this.projectId = projectId
+    this.coordinatorId = coordinatorId
+  }
+
+  onSwarmStarted(totalTasks: number): void {
+    agentBus.publish("project:started", {
+      projectId: this.projectId,
+      projectName: `swarm:${this.swarmId}`,
+      coordinatorId: this.coordinatorId,
+      timestamp: Date.now(),
+    })
+
+    emitCanvas("canvas:node_update", {
+      nodeId: this.projectId,
+      changes: { status: "thinking", label: `Swarm started (${totalTasks} tasks)` },
+    })
+  }
+
+  onTaskStarted(node: TaskNode): void {
+    agentBus.notifyTaskStarted(
+      node.agentId,
+      node.name,
+      0, // task numeric ID not tracked here — DAG uses string IDs
+      node.name,
+      this.projectId
+    )
+
+    emitCanvas("canvas:node_update", {
+      nodeId: node.agentId,
+      changes: { status: STATUS_TO_CANVAS["RUNNING"], label: node.name },
+    })
+  }
+
+  onTaskCompleted(node: TaskNode, progress: number): void {
+    agentBus.notifyTaskCompleted(
+      node.agentId,
+      node.name,
+      0,
+      node.name,
+      this.projectId,
+      node.result ?? ""
+    )
+
+    emitCanvas("canvas:node_update", {
+      nodeId: node.agentId,
+      changes: { status: STATUS_TO_CANVAS["COMPLETED"], progress },
+    })
+
+    // Broadcast overall swarm progress
+    agentBus.publish("message:custom", {
+      fromWorkerId: this.coordinatorId,
+      fromWorkerName: "DAGScheduler",
+      topic: "swarm:progress",
+      content: String(progress),
+      timestamp: Date.now(),
+    })
+  }
+
+  onTaskFailed(node: TaskNode, progress: number): void {
+    agentBus.notifyTaskFailed(
+      node.agentId,
+      node.name,
+      0,
+      node.name,
+      this.projectId,
+      node.error ?? "unknown error"
+    )
+
+    emitCanvas("canvas:node_update", {
+      nodeId: node.agentId,
+      changes: { status: STATUS_TO_CANVAS["FAILED"] },
+    })
+  }
+
+  onSwarmCompleted(result: DAGResult): void {
+    const summary = `Completed ${result.completed.length}/${result.completed.length + result.failed.length} tasks in ${Math.round(result.totalDurationMs / 1000)}s`
+
+    agentBus.publish("project:completed", {
+      projectId: this.projectId,
+      projectName: `swarm:${this.swarmId}`,
+      coordinatorId: this.coordinatorId,
+      summary,
+      timestamp: Date.now(),
+    })
+
+    emitCanvas("canvas:node_update", {
+      nodeId: this.projectId,
+      changes: {
+        status: result.success ? "idle" : "error",
+        progress: 100,
+        label: summary,
+      },
+    })
+  }
+}

package/packages/core/src/swarm/EventBus.ts

@@ -0,0 +1,169 @@
+import { EventEmitter } from "events";
+import { logger } from "../utils/logger.ts";
+
+export interface EventMap {
+  "message:received": {
+    channel: string;
+    userId: string;
+    content: string;
+    timestamp: number;
+    sessionId: string;
+  };
+  "message:sent": {
+    channel: string;
+    userId: string;
+    content: string;
+    messageId: string;
+    sessionId: string;
+  };
+  "agent:thinking": {
+    agentId: string;
+    sessionId: string;
+    stage: "planning" | "executing" | "responding";
+  };
+  "agent:response": {
+    agentId: string;
+    sessionId: string;
+    content: string;
+    toolsUsed: string[];
+    duration: number;
+  };
+  "tool:executing": {
+    toolName: string;
+    args: Record<string, unknown>;
+    sessionId: string;
+  };
+  "tool:completed": {
+    toolName: string;
+    result: unknown;
+    duration: number;
+    success: boolean;
+  };
+  "tool:error": {
+    toolName: string;
+    error: Error;
+    args: Record<string, unknown>;
+  };
+  "error": {
+    source: string;
+    error: Error;
+    context: Record<string, unknown>;
+    recoverable: boolean;
+  };
+  "session:started": {
+    sessionId: string;
+    agentId: string;
+    channel: string;
+    userId: string;
+  };
+  "session:ended": {
+    sessionId: string;
+    duration: number;
+    messageCount: number;
+    reason: "completed" | "cancelled" | "error" | "timeout";
+  };
+  "mcp:connected": {
+    serverName: string;
+    toolsCount: number;
+    resourcesCount: number;
+  };
+  "mcp:disconnected": {
+    serverName: string;
+    reason: string;
+  };
+  "mcp:error": {
+    serverName: string;
+    error: Error;
+  };
+  "channel:started": {
+    channel: string;
+    accountId: string;
+  };
+  "channel:stopped": {
+    channel: string;
+    accountId: string;
+    reason: string;
+  };
+  "gateway:started": {
+    host: string;
+    port: number;
+  };
+  "gateway:stopped": {
+    reason: string;
+  };
+  "pairing:requested": {
+    channel: string;
+    userId: string;
+    code: string;
+    expiresAt: number;
+  };
+  "pairing:approved": {
+    channel: string;
+    userId: string;
+  };
+  "pairing:rejected": {
+    channel: string;
+    userId: string;
+    reason: string;
+  };
+  "pairing:expired": {
+    code: string;
+    channel: string;
+    userId: string;
+  };
+}
+
+export type EventKey = keyof EventMap;
+
+export interface EventHandler<K extends EventKey> {
+  (data: EventMap[K]): void | Promise<void>;
+}
+
+class TypedEventBusImpl {
+  private emitter = new EventEmitter();
+  private logPrefix = "[events]";
+
+  emit<K extends EventKey>(event: K, data: EventMap[K]): void {
+    const enrichedData = {
+      ...data,
+      _eventId: crypto.randomUUID(),
+      _timestamp: Date.now(),
+      _event: event,
+    } as EventMap[K] & { _eventId: string; _timestamp: number; _event: string };
+
+    this.emitter.emit(event, enrichedData);
+
+    if (process.env.DEBUG_EVENTS === "true") {
+      logger.debug(`${this.logPrefix} emitted: ${event}`, { data });
+    }
+  }
+
+  on<K extends EventKey>(event: K, handler: EventHandler<K>): () => void {
+    this.emitter.on(event, handler);
+    return () => this.off(event, handler);
+  }
+
+  once<K extends EventKey>(event: K, handler: EventHandler<K>): void {
+    this.emitter.once(event, handler);
+  }
+
+  off<K extends EventKey>(event: K, handler: EventHandler<K>): void {
+    this.emitter.off(event, handler);
+  }
+
+  removeAllListeners<K extends EventKey>(event?: K): void {
+    if (event) {
+      this.emitter.removeAllListeners(event);
+    } else {
+      this.emitter.removeAllListeners();
+    }
+  }
+
+  listenerCount<K extends EventKey>(event: K): number {
+    return this.emitter.listenerCount(event);
+  }
+}
+
+export const eventBus = new TypedEventBusImpl();
+
+export type TypedEventBus = typeof eventBus;