@johpaz/hive-sdk 0.1.4 → 0.1.6

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

@@ -1,122 +0,0 @@
-/**
- * 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

@@ -1,192 +0,0 @@
-/**
- * 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
-          }
-        }
-      }
-    }
-  }
-}

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

@@ -1,97 +0,0 @@
-/**
- * DAGScheduler — TaskNode
- *
- * Represents a single node in the task graph. Tracks its own state,
- * retry count, timing, and the results of its dependencies.
- */
-
-export type NodeStatus = "PENDING" | "READY" | "RUNNING" | "COMPLETED" | "FAILED"
-
-export interface TaskNodeConfig {
-  /** Unique ID within this graph (can match SQLite task.id) */
-  id: string
-  /** agents.id of the worker agent to execute */
-  agentId: string
-  /** Human-readable name for logging */
-  name: string
-  /** Task description passed to the worker */
-  taskDescription: string
-  /** IDs of other TaskNodes that must complete first */
-  deps: string[]
-  /** Timeout in ms before the task is cancelled. Default: 120_000 */
-  timeout?: number
-  /** How many times to retry on failure. Default: 1 */
-  maxRetries?: number
-  /** Priority hint for PriorityStrategy. Higher = runs first. Default: 0 */
-  priority?: number
-  /** Optional arbitrary metadata forwarded to the worker */
-  metadata?: Record<string, unknown>
-}
-
-export class TaskNode {
-  readonly id: string
-  readonly agentId: string
-  readonly name: string
-  readonly taskDescription: string
-  readonly deps: string[]
-  readonly timeout: number
-  readonly maxRetries: number
-  readonly priority: number
-  readonly metadata: Record<string, unknown>
-
-  status: NodeStatus = "PENDING"
-  retryCount = 0
-  startedAt?: number
-  completedAt?: number
-  result?: string
-  error?: string
-
-  constructor(config: TaskNodeConfig) {
-    this.id = config.id
-    this.agentId = config.agentId
-    this.name = config.name
-    this.taskDescription = config.taskDescription
-    this.deps = config.deps
-    this.timeout = config.timeout ?? 120_000
-    this.maxRetries = config.maxRetries ?? 1
-    this.priority = config.priority ?? 0
-    this.metadata = config.metadata ?? {}
-  }
-
-  /** Returns true if all dependency IDs are in the completed set */
-  canStart(completedIds: Set<string>): boolean {
-    return this.deps.every(dep => completedIds.has(dep))
-  }
-
-  markReady(): void {
-    this.status = "READY"
-  }
-
-  markRunning(): void {
-    this.status = "RUNNING"
-    this.startedAt = Date.now()
-  }
-
-  markCompleted(result: string): void {
-    this.status = "COMPLETED"
-    this.completedAt = Date.now()
-    this.result = result
-  }
-
-  markFailed(error: string): void {
-    this.status = "FAILED"
-    this.completedAt = Date.now()
-    this.error = error
-  }
-
-  canRetry(): boolean {
-    return this.retryCount < this.maxRetries
-  }
-
-  /** Elapsed time in seconds since start, or total duration if done */
-  elapsedSeconds(): number {
-    if (!this.startedAt) return 0
-    const end = this.completedAt ?? Date.now()
-    return Math.round((end - this.startedAt) / 1000)
-  }
-}

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

@@ -1,22 +0,0 @@
-/**
- * DAGScheduler — Result types
- */
-
-export interface NodeSummary {
-  id: string
-  name: string
-  status: "COMPLETED" | "FAILED"
-  durationMs: number
-  result?: string
-  error?: string
-  retries: number
-}
-
-export interface DAGResult {
-  swarmId: string
-  totalDurationMs: number
-  completed: NodeSummary[]
-  failed: NodeSummary[]
-  /** true if all nodes completed successfully */
-  success: boolean
-}

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

@@ -1,37 +0,0 @@
-/**
- * DAGScheduler — Custom errors
- */
-
-export class CyclicDependencyError extends Error {
-  readonly cycle: string[]
-
-  constructor(cycle: string[]) {
-    super(`Cyclic dependency detected: ${cycle.join(" → ")}`)
-    this.name = "CyclicDependencyError"
-    this.cycle = cycle
-  }
-}
-
-export class TaskTimeoutError extends Error {
-  readonly nodeId: string
-  readonly timeoutMs: number
-
-  constructor(nodeId: string, timeoutMs: number) {
-    super(`Task "${nodeId}" timed out after ${timeoutMs}ms`)
-    this.name = "TaskTimeoutError"
-    this.nodeId = nodeId
-    this.timeoutMs = timeoutMs
-  }
-}
-
-export class TaskFailureError extends Error {
-  readonly nodeId: string
-  readonly cause: Error
-
-  constructor(nodeId: string, cause: Error) {
-    super(`Task "${nodeId}" failed: ${cause.message}`)
-    this.name = "TaskFailureError"
-    this.nodeId = nodeId
-    this.cause = cause
-  }
-}

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

@@ -1,26 +0,0 @@
-/**
- * DAGScheduler — Public API
- *
- * Usage:
- *   import { DAGScheduler, TaskGraph, ParallelStrategy } from "./dag"
- */
-
-export { DAGScheduler } from "./DAGScheduler"
-export type { DAGSchedulerOptions } from "./DAGScheduler"
-
-export { TaskGraph } from "./TaskGraph"
-export { TaskNode } from "./TaskNode"
-export type { TaskNodeConfig, NodeStatus } from "./TaskNode"
-export type { DAGResult, NodeSummary } from "./TaskResult"
-
-export { AgentExecutor } from "./AgentExecutor"
-export { EventBridge } from "./EventBridge"
-
-export { CyclicDependencyError, TaskTimeoutError, TaskFailureError } from "./errors"
-
-export { ParallelStrategy } from "./strategies/ParallelStrategy"
-export type { ExecutionStrategy } from "./strategies/ParallelStrategy"
-export { PriorityStrategy } from "./strategies/PriorityStrategy"
-
-export { createResearchGraph } from "./presets/ResearchPreset"
-export type { ResearchAgentIds } from "./presets/ResearchPreset"

package/packages/core/src/scheduler/dag/presets/ResearchPreset.ts

@@ -1,97 +0,0 @@
-/**
- * ResearchPreset — Pre-configured DAG for general research swarms
- *
- * Dependency graph:
- *   ResearchAgent ─┐
- *   StrategyAgent  ├── SynthesisAgent  (all three run in parallel)
- *   DesignAgent   ─┘
- *
- * All three parallel agents are fully independent. SynthesisAgent
- * waits for all three and combines their outputs into a final deliverable.
- *
- * Usage:
- *   const graph = createResearchGraph(
- *     { research: "agent-uuid-1", strategy: "agent-uuid-2",
- *       design: "agent-uuid-3", synthesis: "agent-uuid-4" },
- *     "Design a distributed caching strategy for the platform"
- *   )
- *   await scheduler.execute(graph, { projectId, coordinatorId })
- */
-
-import { TaskGraph } from "../TaskGraph"
-import type { TaskNodeConfig } from "../TaskNode"
-
-export interface ResearchAgentIds {
-  research: string
-  strategy: string
-  design: string
-  synthesis: string
-}
-
-export function createResearchGraph(
-  agentIds: ResearchAgentIds,
-  topic: string,
-  options: {
-    researchTimeout?: number
-    strategyTimeout?: number
-    designTimeout?: number
-    synthesisTimeout?: number
-  } = {}
-): TaskGraph {
-  const nodes: TaskNodeConfig[] = [
-    {
-      id: "research",
-      agentId: agentIds.research,
-      name: "ResearchAgent",
-      taskDescription:
-        `Research the following topic using available knowledge bases and sources: "${topic}".` +
-        ` Output: { findings: string[], sources: string[], keyInsights: string[] }.`,
-      deps: [],
-      timeout: options.researchTimeout ?? 120_000,
-      maxRetries: 1,
-      priority: 8,
-    },
-    {
-      id: "strategy",
-      agentId: agentIds.strategy,
-      name: "StrategyAgent",
-      taskDescription:
-        `Design a strategic framework or approach for: "${topic}".` +
-        ` Work independently — you will NOT have the research findings yet.` +
-        ` Output: { approach: string, phases: string[], risks: string[], successMetrics: string[] }.`,
-      deps: [],
-      timeout: options.strategyTimeout ?? 90_000,
-      maxRetries: 1,
-      priority: 8,
-    },
-    {
-      id: "design",
-      agentId: agentIds.design,
-      name: "DesignAgent",
-      taskDescription:
-        `Design the structure or architecture for: "${topic}".` +
-        ` Work independently — focus on structure, not content.` +
-        ` Output: { structure: string, components: string[], diagram: string (ASCII or Mermaid) }.`,
-      deps: [],
-      timeout: options.designTimeout ?? 90_000,
-      maxRetries: 1,
-      priority: 8,
-    },
-    {
-      id: "synthesis",
-      agentId: agentIds.synthesis,
-      name: "SynthesisAgent",
-      taskDescription:
-        `Synthesize the research findings, strategic framework, and design structure into a cohesive deliverable.` +
-        ` The dependency context contains all three agents' outputs.` +
-        ` Topic: "${topic}".` +
-        ` Output a comprehensive, well-structured document that combines all inputs coherently.`,
-      deps: ["research", "strategy", "design"],
-      timeout: options.synthesisTimeout ?? 150_000,
-      maxRetries: 2,
-      priority: 0,
-    },
-  ]
-
-  return new TaskGraph(nodes)
-}

package/packages/core/src/scheduler/dag/strategies/ParallelStrategy.ts

@@ -1,21 +0,0 @@
-/**
- * ParallelStrategy — executes DAG nodes in parallel as slots become available
- *
- * Picks nodes from the READY queue in FIFO order.
- * Nodes are launched immediately when a worker slot is available,
- * otherwise they wait in the queue.
- */
-
-import { TaskNode } from "../TaskNode"
-
-export interface ExecutionStrategy {
-  pick(queue: TaskNode[]): TaskNode | undefined
-  /** Called once at graph start to allow strategy-level initialization */
-  initialize?(nodes: Map<string, TaskNode>): void
-}
-
-export class ParallelStrategy implements ExecutionStrategy {
-  pick(queue: TaskNode[]): TaskNode | undefined {
-    return queue.shift()
-  }
-}

package/packages/core/src/scheduler/dag/strategies/PriorityStrategy.ts

@@ -1,46 +0,0 @@
-/**
- * PriorityStrategy — for research swarms
- *
- * Boosts the priority of nodes on the critical path so they run first
- * when slots are limited. Within same effective priority, FIFO order applies.
- */
-
-import { TaskNode } from "../TaskNode"
-import { TaskGraph } from "../TaskGraph"
-import type { ExecutionStrategy } from "./ParallelStrategy"
-
-export class PriorityStrategy implements ExecutionStrategy {
-  private criticalPathSet = new Set<string>()
-  private readonly CRITICAL_BOOST = 1000
-
-  initialize(nodes: Map<string, TaskNode>): void {
-    // Build a temporary graph for critical path calculation
-    const configs = [...nodes.values()].map(n => ({
-      id: n.id,
-      agentId: n.agentId,
-      name: n.name,
-      taskDescription: n.taskDescription,
-      deps: n.deps,
-      timeout: n.timeout,
-      maxRetries: n.maxRetries,
-      priority: n.priority,
-    }))
-    const graph = new TaskGraph(configs)
-    for (const id of graph.getCriticalPath()) {
-      this.criticalPathSet.add(id)
-    }
-  }
-
-  pick(queue: TaskNode[]): TaskNode | undefined {
-    if (queue.length === 0) return undefined
-
-    // Sort: critical path nodes first, then by node.priority desc, then FIFO (stable)
-    queue.sort((a, b) => {
-      const aBoost = this.criticalPathSet.has(a.id) ? this.CRITICAL_BOOST : 0
-      const bBoost = this.criticalPathSet.has(b.id) ? this.CRITICAL_BOOST : 0
-      return (b.priority + bBoost) - (a.priority + aBoost)
-    })
-
-    return queue.shift()
-  }
-}