@ai-setting/roy-agent-core 1.5.88 → 1.5.89

package/dist/shared/@ai-setting/roy-agent-core-4yq23m5g.js

@@ -0,0 +1,421 @@
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/engine/dag-manager.ts
+class DAGManager {
+  workflow;
+  nodeMap;
+  extendedDefinition = null;
+  cachedAnalysis = null;
+  allowCycles;
+  constructor(workflow, options) {
+    if (!workflow.nodes || workflow.nodes.length === 0) {
+      throw new Error("At least one node is required");
+    }
+    this.workflow = workflow;
+    this.nodeMap = new Map;
+    this.allowCycles = options?.allowCycles ?? false;
+    for (const node of workflow.nodes) {
+      if (node.id === "") {
+        throw new Error("Node ID cannot be empty");
+      }
+      if (this.nodeMap.has(node.id)) {
+        throw new Error(`Duplicate node ID: ${node.id}`);
+      }
+      this.nodeMap.set(node.id, node);
+    }
+  }
+  getExtendedDefinition() {
+    if (this.extendedDefinition) {
+      return this.extendedDefinition;
+    }
+    const analysis = this.analyze();
+    this.extendedDefinition = {
+      ...this.workflow,
+      computedEntry: analysis.entryNodes,
+      nodeMap: this.nodeMap,
+      topologicalOrder: this.getTopologicalOrder()
+    };
+    return this.extendedDefinition;
+  }
+  analyze() {
+    if (this.cachedAnalysis) {
+      return this.cachedAnalysis;
+    }
+    const dependencies = this.buildDependenciesMap();
+    const dependents = this.buildDependentsMap(dependencies);
+    const entryNodes = this.findEntryNodes(dependencies);
+    const exitNodes = this.findExitNodes(dependents);
+    const levels = this.computeLevels(dependencies);
+    const criticalPath = this.findCriticalPath(levels, dependencies);
+    this.cachedAnalysis = {
+      entryNodes,
+      exitNodes,
+      levels,
+      dependencies,
+      dependents,
+      criticalPath
+    };
+    return this.cachedAnalysis;
+  }
+  buildDependenciesMap() {
+    const dependencies = new Map;
+    for (const node of this.workflow.nodes) {
+      const deps = node.depends_on || [];
+      dependencies.set(node.id, [...deps]);
+    }
+    if (this.workflow.edges) {
+      for (const edge of this.workflow.edges) {
+        const targetDeps = dependencies.get(edge.to);
+        if (!targetDeps)
+          continue;
+        if (targetDeps.includes(edge.from))
+          continue;
+        if (!this.isReachable(edge.from, edge.to, dependencies)) {
+          targetDeps.push(edge.from);
+        }
+      }
+    }
+    return dependencies;
+  }
+  isReachable(source, target, dependencies) {
+    if (source === target)
+      return true;
+    const visited = new Set;
+    const queue = [source];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current === target)
+        return true;
+      if (visited.has(current))
+        continue;
+      visited.add(current);
+      const deps = dependencies.get(current) || [];
+      for (const dep of deps) {
+        if (!visited.has(dep))
+          queue.push(dep);
+      }
+    }
+    return false;
+  }
+  buildDependentsMap(dependencies) {
+    const dependentsMap = new Map;
+    for (const nodeId of dependencies.keys()) {
+      dependentsMap.set(nodeId, []);
+    }
+    for (const [nodeId, deps] of dependencies.entries()) {
+      for (const dep of deps) {
+        const nodeDependents = dependentsMap.get(dep) || [];
+        nodeDependents.push(nodeId);
+        dependentsMap.set(dep, nodeDependents);
+      }
+    }
+    return dependentsMap;
+  }
+  findEntryNodes(dependencies) {
+    const entryNodes = [];
+    for (const [nodeId, deps] of dependencies.entries()) {
+      if (deps.length === 0) {
+        entryNodes.push(nodeId);
+      }
+    }
+    return entryNodes;
+  }
+  findExitNodes(dependents) {
+    const exitNodes = [];
+    for (const [nodeId, deps] of dependents.entries()) {
+      if (deps.length === 0) {
+        exitNodes.push(nodeId);
+      }
+    }
+    return exitNodes;
+  }
+  computeLevels(dependencies) {
+    const levels = [];
+    const assigned = new Set;
+    const nodeLevels = new Map;
+    const dependentsMap = this.buildDependentsMap(dependencies);
+    const entryNodes = this.findEntryNodes(dependencies);
+    const queue = [];
+    for (const entry of entryNodes) {
+      queue.push({ nodeId: entry, level: 0 });
+      nodeLevels.set(entry, 0);
+    }
+    while (queue.length > 0) {
+      const { nodeId, level } = queue.shift();
+      if (assigned.has(nodeId)) {
+        const currentLevel = nodeLevels.get(nodeId) || 0;
+        if (level > currentLevel) {
+          nodeLevels.set(nodeId, level);
+        }
+        continue;
+      }
+      assigned.add(nodeId);
+      nodeLevels.set(nodeId, level);
+      const dependentsOfNode = dependentsMap.get(nodeId) || [];
+      for (const dependent of dependentsOfNode) {
+        if (!assigned.has(dependent)) {
+          queue.push({ nodeId: dependent, level: level + 1 });
+        }
+      }
+    }
+    for (const nodeId of dependencies.keys()) {
+      if (!nodeLevels.has(nodeId)) {
+        nodeLevels.set(nodeId, 0);
+      }
+    }
+    const maxLevel = Math.max(...nodeLevels.values(), 0);
+    for (let i = 0;i <= maxLevel; i++) {
+      levels.push([]);
+    }
+    for (const [nodeId, level] of nodeLevels.entries()) {
+      levels[level].push(nodeId);
+    }
+    return levels;
+  }
+  findCriticalPath(levels, dependencies) {
+    if (levels.length === 0) {
+      return [];
+    }
+    const longestPath = new Map;
+    const allNodes = [];
+    for (const level of levels) {
+      allNodes.push(...level);
+    }
+    for (const nodeId of allNodes) {
+      const deps = dependencies.get(nodeId) || [];
+      if (deps.length === 0) {
+        longestPath.set(nodeId, { length: 1, path: [nodeId] });
+      } else {
+        let maxLength2 = 0;
+        let maxPath = [];
+        for (const dep of deps) {
+          const depInfo = longestPath.get(dep);
+          if (depInfo && depInfo.length > maxLength2) {
+            maxLength2 = depInfo.length;
+            maxPath = depInfo.path;
+          }
+        }
+        longestPath.set(nodeId, {
+          length: maxLength2 + 1,
+          path: [...maxPath, nodeId]
+        });
+      }
+    }
+    let maxLength = 0;
+    let criticalPath = [];
+    for (const [, info] of longestPath.entries()) {
+      if (info.length > maxLength) {
+        maxLength = info.length;
+        criticalPath = info.path;
+      }
+    }
+    return criticalPath;
+  }
+  getTopologicalOrder() {
+    const dependencies = this.buildDependenciesMap();
+    const dependents = this.buildDependentsMap(dependencies);
+    const inDegree = new Map;
+    for (const nodeId of dependencies.keys()) {
+      inDegree.set(nodeId, dependencies.get(nodeId)?.length || 0);
+    }
+    const queue = [];
+    for (const [nodeId, degree] of inDegree.entries()) {
+      if (degree === 0) {
+        queue.push(nodeId);
+      }
+    }
+    const result = [];
+    while (queue.length > 0) {
+      const nodeId = queue.shift();
+      result.push(nodeId);
+      const nodeDependents = dependents.get(nodeId) || [];
+      for (const dependent of nodeDependents) {
+        const currentDegree = inDegree.get(dependent) || 0;
+        inDegree.set(dependent, currentDegree - 1);
+        if (currentDegree - 1 === 0) {
+          queue.push(dependent);
+        }
+      }
+    }
+    return result;
+  }
+  getReadyNodes(completedNodes) {
+    const dependencies = this.buildDependenciesMap();
+    const ready = [];
+    for (const nodeId of dependencies.keys()) {
+      if (completedNodes.has(nodeId)) {
+        continue;
+      }
+      if (this.areDependenciesMet(nodeId, completedNodes)) {
+        ready.push(nodeId);
+      }
+    }
+    return ready;
+  }
+  areDependenciesMet(nodeId, completedNodes) {
+    const analysis = this.analyze();
+    const deps = analysis.dependencies.get(nodeId);
+    if (!deps) {
+      return true;
+    }
+    for (const dep of deps) {
+      if (!completedNodes.has(dep)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isCyclic() {
+    const dependencies = this.buildDependenciesMap();
+    const order = this.getTopologicalOrderInternal(dependencies);
+    return order.length !== this.workflow.nodes.length;
+  }
+  getTopologicalOrderInternal(dependencies) {
+    const dependents = this.buildDependentsMap(dependencies);
+    const inDegree = new Map;
+    for (const nodeId of dependencies.keys()) {
+      inDegree.set(nodeId, dependencies.get(nodeId)?.length || 0);
+    }
+    const queue = [];
+    for (const [nodeId, degree] of inDegree.entries()) {
+      if (degree === 0) {
+        queue.push(nodeId);
+      }
+    }
+    const result = [];
+    while (queue.length > 0) {
+      const nodeId = queue.shift();
+      result.push(nodeId);
+      const nodeDependents = dependents.get(nodeId) || [];
+      for (const dependent of nodeDependents) {
+        const currentDegree = inDegree.get(dependent) || 0;
+        inDegree.set(dependent, currentDegree - 1);
+        if (currentDegree - 1 === 0) {
+          queue.push(dependent);
+        }
+      }
+    }
+    return result;
+  }
+  validate(options) {
+    const errors = [];
+    const nodeIds = new Set;
+    for (const node of this.workflow.nodes) {
+      if (node.id === "") {
+        errors.push("Node ID cannot be empty");
+        continue;
+      }
+      if (nodeIds.has(node.id)) {
+        errors.push(`Duplicate node ID: ${node.id}`);
+      }
+      nodeIds.add(node.id);
+    }
+    for (const node of this.workflow.nodes) {
+      const deps = node.depends_on || [];
+      for (const dep of deps) {
+        if (!nodeIds.has(dep)) {
+          errors.push(`Node '${node.id}' depends on non-existent node '${dep}'`);
+        }
+      }
+    }
+    if (!this.allowCycles && !options?.skipCycleCheck && this.isCyclic()) {
+      errors.push("Workflow contains a cycle");
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  addNode(node) {
+    if (!node.id || node.id.trim() === "") {
+      throw new Error("Node ID cannot be empty");
+    }
+    if (this.nodeMap.has(node.id)) {
+      throw new Error(`Node with ID '${node.id}' already exists`);
+    }
+    const deps = node.depends_on || [];
+    for (const dep of deps) {
+      if (!this.nodeMap.has(dep)) {
+        throw new Error(`Cannot add node '${node.id}': depends on non-existent node '${dep}'`);
+      }
+    }
+    const originalNodes = [...this.workflow.nodes];
+    this.workflow.nodes.push(node);
+    if (this.isCyclic()) {
+      this.workflow.nodes = originalNodes;
+      throw new Error(`Cannot add node '${node.id}': would create a cycle in the workflow`);
+    }
+    this.nodeMap.set(node.id, node);
+    this.cachedAnalysis = null;
+    this.extendedDefinition = null;
+  }
+  removeNode(nodeId) {
+    if (!this.nodeMap.has(nodeId)) {
+      throw new Error(`Node '${nodeId}' does not exist`);
+    }
+    const dependents = this.getDependents(nodeId);
+    if (dependents.length > 0) {
+      throw new Error(`Cannot remove node '${nodeId}': other nodes depend on it: ${dependents.join(", ")}`);
+    }
+    this.workflow.nodes = this.workflow.nodes.filter((n) => n.id !== nodeId);
+    this.nodeMap.delete(nodeId);
+    this.cachedAnalysis = null;
+    this.extendedDefinition = null;
+  }
+  getDependents(nodeId) {
+    const analysis = this.analyze();
+    return analysis.dependents.get(nodeId) || [];
+  }
+  getDownstreamUntil(fromNodeId, untilNodeId) {
+    const result = [];
+    const visited = new Set;
+    const queue = [...this.getDependents(fromNodeId)];
+    while (queue.length > 0) {
+      const nodeId = queue.shift();
+      if (visited.has(nodeId))
+        continue;
+      visited.add(nodeId);
+      result.push(nodeId);
+      if (nodeId === untilNodeId) {
+        continue;
+      }
+      for (const dependent of this.getDependents(nodeId)) {
+        if (!visited.has(dependent)) {
+          queue.push(dependent);
+        }
+      }
+    }
+    return result;
+  }
+  getDefinition() {
+    return this.workflow;
+  }
+  getNode(nodeId) {
+    return this.nodeMap.get(nodeId);
+  }
+  getNodeIds() {
+    return Array.from(this.nodeMap.keys());
+  }
+  getNodeCount() {
+    return this.nodeMap.size;
+  }
+  buildEdges(explicitEdges = []) {
+    const derivedEdges = [];
+    const explicitEdgeSet = new Set(explicitEdges.map((e) => `${e.from}->${e.to}`));
+    for (const node of this.workflow.nodes) {
+      const deps = node.depends_on || [];
+      for (const dep of deps) {
+        const edgeKey = `${dep}->${node.id}`;
+        if (!explicitEdgeSet.has(edgeKey)) {
+          derivedEdges.push({ from: dep, to: node.id });
+        }
+      }
+    }
+    return [...explicitEdges, ...derivedEdges];
+  }
+}
+var init_dag_manager = () => {};
+
+export { DAGManager, init_dag_manager };