@johpaz/hive-agents 0.0.35 → 0.0.36

package/packages/core/src/scheduler/dag/AgentExecutor.ts

@@ -0,0 +1,53 @@
+/**
+ * DAGScheduler — AgentExecutor
+ *
+ * Bridges the DAGScheduler to the existing runAgentIsolated() call.
+ * Adds timeout enforcement via Promise.race().
+ *
+ * NOTE: There are no Bun Worker threads in Hive OSS. "Workers" are logical
+ * agents stored in the DB and executed as async calls in the same process.
+ * Parallelism is achieved by launching multiple runAgentIsolated() calls
+ * concurrently without awaiting each one serially.
+ */
+
+import { runAgentIsolated } from "../../agent/agent-loop"
+import { TaskNode } from "./TaskNode"
+import { TaskTimeoutError } from "./errors"
+
+export class AgentExecutor {
+  /**
+   * Execute a TaskNode.
+   * Injects dependency results into the task description as context.
+   * Returns the final text output from the agent.
+   */
+  async execute(
+    node: TaskNode,
+    depResults: Record<string, string>,
+    threadId: string
+  ): Promise<string> {
+    const hasDeps = Object.keys(depResults).length > 0
+    const contextBlock = hasDeps
+      ? `\n\n---\nContext from completed dependencies:\n${JSON.stringify(depResults, null, 2)}\n---`
+      : ""
+
+    const taskDescription = node.taskDescription + contextBlock
+
+    const agentPromise = runAgentIsolated({
+      agentId: node.agentId,
+      taskDescription,
+      threadId,
+    })
+
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      const t = setTimeout(() => {
+        reject(new TaskTimeoutError(node.id, node.timeout))
+      }, node.timeout)
+      // Ensure the timeout timer doesn't prevent process exit
+      if (typeof t === "object" && t !== null && "unref" in t) {
+        (t as any).unref()
+      }
+    })
+
+    return Promise.race([agentPromise, timeoutPromise])
+  }
+}

package/packages/core/src/scheduler/dag/DAGScheduler.ts

@@ -0,0 +1,250 @@
+/**
+ * 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"
+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 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> = this.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/scheduler/dag/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 "../../events/agent-bus"
+import { emitCanvas } from "../../canvas/emitter"
+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/scheduler/dag/TaskGraph.ts

@@ -0,0 +1,192 @@
+/**
+ * DAGScheduler — TaskGraph
+ *
+ * Owns the full set of TaskNodes for one swarm execution.
+ * Responsibilities:
+ *   1. Validate no cyclic dependencies (DFS) at construction time
+ *   2. Calculate the critical path (longest weighted path)
+ *   3. Provide runtime queries: ready nodes, overall progress
+ */
+
+import { TaskNode, type TaskNodeConfig } from "./TaskNode"
+import { CyclicDependencyError } from "./errors"
+
+export class TaskGraph {
+  readonly nodes: Map<string, TaskNode>
+  private criticalPath_: string[] | null = null
+
+  constructor(configs: TaskNodeConfig[]) {
+    this.nodes = new Map(configs.map(c => [c.id, new TaskNode(c)]))
+    this.validateNoCycles()
+  }
+
+  // ─── Validation ─────────────────────────────────────────────────────────────
+
+  private validateNoCycles(): void {
+    // Three-color DFS: WHITE=unvisited, GRAY=in-stack, BLACK=done
+    const WHITE = 0, GRAY = 1, BLACK = 2
+    const color = new Map<string, number>()
+
+    for (const id of this.nodes.keys()) color.set(id, WHITE)
+
+    const path: string[] = []
+
+    const visit = (id: string): void => {
+      color.set(id, GRAY)
+      path.push(id)
+
+      const node = this.nodes.get(id)!
+      for (const dep of node.deps) {
+        if (!this.nodes.has(dep)) {
+          throw new Error(`TaskGraph: node "${id}" depends on unknown node "${dep}"`)
+        }
+        const c = color.get(dep)!
+        if (c === GRAY) {
+          // Found back-edge: reconstruct cycle
+          const cycleStart = path.indexOf(dep)
+          throw new CyclicDependencyError([...path.slice(cycleStart), dep])
+        }
+        if (c === WHITE) visit(dep)
+      }
+
+      path.pop()
+      color.set(id, BLACK)
+    }
+
+    for (const id of this.nodes.keys()) {
+      if (color.get(id) === WHITE) visit(id)
+    }
+  }
+
+  // ─── Critical Path ───────────────────────────────────────────────────────────
+
+  /**
+   * Returns the IDs of the longest dependency chain (by node count).
+   * Nodes on this path get higher priority in PriorityStrategy.
+   */
+  getCriticalPath(): string[] {
+    if (this.criticalPath_) return this.criticalPath_
+
+    // longest[id] = length of longest path ending at id (inclusive)
+    const longest = new Map<string, number>()
+    const predecessor = new Map<string, string | null>()
+
+    const compute = (id: string): number => {
+      if (longest.has(id)) return longest.get(id)!
+      const node = this.nodes.get(id)!
+      if (node.deps.length === 0) {
+        longest.set(id, 1)
+        predecessor.set(id, null)
+        return 1
+      }
+      let max = 0
+      let maxPred: string | null = null
+      for (const dep of node.deps) {
+        const l = compute(dep)
+        if (l > max) { max = l; maxPred = dep }
+      }
+      longest.set(id, max + 1)
+      predecessor.set(id, maxPred)
+      return max + 1
+    }
+
+    for (const id of this.nodes.keys()) compute(id)
+
+    // Find sink with max longest
+    let sinkId = ""
+    let maxLen = 0
+    for (const [id, len] of longest) {
+      if (len > maxLen) { maxLen = len; sinkId = id }
+    }
+
+    // Reconstruct path from sink to source, then reverse
+    const path: string[] = []
+    let cur: string | null = sinkId
+    while (cur !== null) {
+      path.push(cur)
+      cur = predecessor.get(cur) ?? null
+    }
+    path.reverse()
+
+    this.criticalPath_ = path
+    return path
+  }
+
+  // ─── Runtime queries ─────────────────────────────────────────────────────────
+
+  /** Nodes that are still PENDING but now have all deps completed */
+  getNewlyReadyNodes(completedIds: Set<string>): TaskNode[] {
+    const ready: TaskNode[] = []
+    for (const node of this.nodes.values()) {
+      if (node.status === "PENDING" && node.canStart(completedIds)) {
+        ready.push(node)
+      }
+    }
+    return ready
+  }
+
+  /** All nodes currently in READY state */
+  getReadyNodes(): TaskNode[] {
+    return [...this.nodes.values()].filter(n => n.status === "READY")
+  }
+
+  /** IDs of all COMPLETED nodes */
+  getCompletedIds(): Set<string> {
+    const ids = new Set<string>()
+    for (const [id, node] of this.nodes) {
+      if (node.status === "COMPLETED") ids.add(id)
+    }
+    return ids
+  }
+
+  /** Collect results of all deps for a given node */
+  getDepResults(nodeId: string): Record<string, string> {
+    const node = this.nodes.get(nodeId)!
+    const results: Record<string, string> = {}
+    for (const dep of node.deps) {
+      const depNode = this.nodes.get(dep)!
+      if (depNode.result !== undefined) results[dep] = depNode.result
+    }
+    return results
+  }
+
+  /** 0–100 progress based on nodes in terminal state */
+  getProgress(): number {
+    const total = this.nodes.size
+    if (total === 0) return 100
+    let done = 0
+    for (const node of this.nodes.values()) {
+      if (node.status === "COMPLETED" || node.status === "FAILED") done++
+    }
+    return Math.round((done / total) * 100)
+  }
+
+  /** True when every node is in a terminal state */
+  isComplete(): boolean {
+    for (const node of this.nodes.values()) {
+      if (node.status === "PENDING" || node.status === "READY" || node.status === "RUNNING") {
+        return false
+      }
+    }
+    return true
+  }
+
+  /** Propagate FAILED status to all nodes that depend (directly or transitively) on failedId */
+  propagateFailure(failedId: string, reason: string): void {
+    const failedSet = new Set<string>([failedId])
+
+    let changed = true
+    while (changed) {
+      changed = false
+      for (const node of this.nodes.values()) {
+        if (node.status === "PENDING" || node.status === "READY") {
+          if (node.deps.some(d => failedSet.has(d))) {
+            node.markFailed(`dependency_failed: ${reason}`)
+            failedSet.add(node.id)
+            changed = true
+          }
+        }
+      }
+    }
+  }
+}