@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-chunk-YVPURWS6.mjs

@@ -0,0 +1,40 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  WorkflowRegistry,
+  buildOpenApi,
+  planRoutes
+} from "./flow-weaver-chunk-MHJ4N652.mjs";
+import {
+  dump
+} from "./flow-weaver-chunk-3BSYCWPL.mjs";
+
+// src/server/openapi-document.ts
+async function openApiForDirectory(workflowDir, options = {}) {
+  const registry = new WorkflowRegistry(workflowDir);
+  await registry.initialize();
+  const endpoints = registry.getAllEndpoints();
+  const plan = planRoutes(endpoints.map((endpoint) => ({ name: endpoint.name, routes: endpoint.routes ?? [], endpoint })));
+  const mounted = plan.mounted.map(({ owner, route }) => ({
+    endpoint: owner.endpoint,
+    route,
+    keys: [...route.path.matchAll(/:([A-Za-z_][A-Za-z0-9_]*)/g)].map((m) => m[1])
+  }));
+  const doc = buildOpenApi({
+    endpoints,
+    mounted,
+    legacy: options.legacy !== false,
+    secured: options.auth !== false,
+    serverUrl: options.serverUrl,
+    info: { title: options.title, version: options.version, description: options.description }
+  });
+  return { doc, workflowCount: endpoints.length, routeCount: mounted.length, problems: plan.problems };
+}
+function formatOpenApi(doc, format) {
+  return format === "yaml" ? dump(doc, { lineWidth: 120, noRefs: true }) : JSON.stringify(doc, null, 2);
+}
+
+export {
+  openApiForDirectory,
+  formatOpenApi
+};

package/dist/cli/flow-weaver-chunk-Z44JK332.mjs

@@ -0,0 +1,582 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  AnnotationParser
+} from "./flow-weaver-chunk-APX6MQ5A.mjs";
+import {
+  Ze
+} from "./flow-weaver-chunk-GAQXZHNO.mjs";
+import {
+  RESERVED_NODE_NAMES,
+  isExitNode,
+  isFailurePort,
+  isStartNode,
+  isSuccessPort
+} from "./flow-weaver-chunk-DRN7KPWY.mjs";
+
+// src/api/port-references.ts
+function validatePortReference(ref) {
+  if (typeof ref === "string") {
+    const parts = ref.split(".");
+    if (parts.length !== 2) {
+      throw new Error(
+        `Invalid port reference format: "${ref}". Expected "nodeId.portName"`
+      );
+    }
+    return { node: parts[0], port: parts[1] };
+  }
+  if (!ref.node || !ref.port) {
+    throw new Error(
+      `Invalid port reference: missing node or port property`
+    );
+  }
+  return ref;
+}
+function portReferencesEqual(a, b) {
+  return a.node === b.node && a.port === b.port && (a.scope ?? null) === (b.scope ?? null);
+}
+
+// src/generator/control-flow.ts
+function buildControlFlowGraph(workflow, nodeTypes) {
+  const graph = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  graph.set(RESERVED_NODE_NAMES.START, []);
+  inDegree.set(RESERVED_NODE_NAMES.START, 0);
+  graph.set(RESERVED_NODE_NAMES.EXIT, []);
+  inDegree.set(RESERVED_NODE_NAMES.EXIT, 0);
+  workflow.instances.forEach((instance) => {
+    if (isPerPortScopedChild(instance, workflow, nodeTypes)) {
+      return;
+    }
+    graph.set(instance.id, []);
+    inDegree.set(instance.id, 0);
+  });
+  workflow.connections.forEach((conn) => {
+    const fromNode = conn.from.node;
+    const toNode = conn.to.node;
+    if (conn.from.scope || conn.to.scope) {
+      return;
+    }
+    const fromInstance = workflow.instances.find((i) => i.id === fromNode);
+    const toInstance = workflow.instances.find((i) => i.id === toNode);
+    if (fromInstance && isPerPortScopedChild(fromInstance, workflow, nodeTypes) || toInstance && isPerPortScopedChild(toInstance, workflow, nodeTypes)) {
+      return;
+    }
+    if (graph.has(fromNode) && graph.has(toNode)) {
+      const successors = graph.get(fromNode) || [];
+      if (!successors.includes(toNode)) {
+        successors.push(toNode);
+        graph.set(fromNode, successors);
+        inDegree.set(toNode, (inDegree.get(toNode) || 0) + 1);
+      }
+    }
+  });
+  workflow.instances.forEach((instance) => {
+    if (isPerPortScopedChild(instance, workflow, nodeTypes)) {
+      return;
+    }
+    if ((inDegree.get(instance.id) || 0) === 0) {
+      const startSuccessors = graph.get(RESERVED_NODE_NAMES.START) || [];
+      if (!startSuccessors.includes(instance.id)) {
+        startSuccessors.push(instance.id);
+        graph.set(RESERVED_NODE_NAMES.START, startSuccessors);
+        inDegree.set(instance.id, 1);
+      }
+    }
+  });
+  workflow.instances.forEach((instance) => {
+    if (isPerPortScopedChild(instance, workflow, nodeTypes)) {
+      return;
+    }
+    const successors = graph.get(instance.id) || [];
+    if (successors.length === 0) {
+      successors.push(RESERVED_NODE_NAMES.EXIT);
+      graph.set(instance.id, successors);
+      inDegree.set(RESERVED_NODE_NAMES.EXIT, (inDegree.get(RESERVED_NODE_NAMES.EXIT) || 0) + 1);
+    }
+  });
+  return { graph, inDegree };
+}
+function performKahnsTopologicalSort(controlFlowGraph) {
+  const executionOrder = [];
+  const inDegree = new Map(controlFlowGraph.inDegree);
+  const queue = [];
+  inDegree.forEach((degree, node) => {
+    if (degree === 0) {
+      queue.push(node);
+    }
+  });
+  while (queue.length > 0) {
+    const node = queue.shift();
+    executionOrder.push(node);
+    const successors = controlFlowGraph.graph.get(node) || [];
+    successors.forEach((successor) => {
+      const newDegree = (inDegree.get(successor) || 0) - 1;
+      inDegree.set(successor, newDegree);
+      if (newDegree === 0) {
+        queue.push(successor);
+      }
+    });
+  }
+  if (executionOrder.length !== controlFlowGraph.graph.size) {
+    const cycleNodes = [];
+    inDegree.forEach((degree, node) => {
+      if (degree > 0 && !executionOrder.includes(node)) {
+        cycleNodes.push(node);
+      }
+    });
+    throw new Error(
+      `Circular dependency detected in workflow. Nodes in cycle: ${cycleNodes.join(", ")}`
+    );
+  }
+  return executionOrder;
+}
+function findAllBranchingNodes(workflow, nodeTypes) {
+  const branchingNodes = /* @__PURE__ */ new Set();
+  workflow.connections.forEach((conn) => {
+    const nodeName = conn.from.node;
+    const portName = conn.from.port;
+    if (isSuccessPort(portName) || isFailurePort(portName)) {
+      const instance = workflow.instances.find((i) => i.id === nodeName);
+      if (instance && isPerPortScopedChild(instance, workflow, nodeTypes)) {
+        return;
+      }
+      branchingNodes.add(nodeName);
+    }
+  });
+  return branchingNodes;
+}
+function isPerPortScopedChild(instance, workflow, nodeTypes) {
+  if (!instance.parent) return false;
+  const parentInstance = workflow.instances.find((i) => i.id === instance.parent.id);
+  if (!parentInstance) return false;
+  const parentNodeType = nodeTypes.find((nt) => nt.name === parentInstance.nodeType || nt.functionName === parentInstance.nodeType);
+  if (!parentNodeType) return false;
+  const scopeName = instance.parent.scope;
+  const hasOutputWithScope = Object.values(parentNodeType.outputs).some(
+    (port) => port.scope === scopeName
+  );
+  const hasInputWithScope = Object.values(parentNodeType.inputs).some(
+    (port) => port.scope === scopeName
+  );
+  return hasOutputWithScope || hasInputWithScope;
+}
+function findNodesInBranch(branchNode, branchPort, workflow, allNodes, stopAtBranchingNodes) {
+  const reachable = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [];
+  workflow.connections.forEach((conn) => {
+    const fromNode = conn.from.node;
+    const fromPort = conn.from.port;
+    const toNode = conn.to.node;
+    if (fromNode === branchNode && fromPort === branchPort) {
+      queue.push(toNode);
+    }
+  });
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current) || isExitNode(current) || isStartNode(current)) {
+      continue;
+    }
+    visited.add(current);
+    if (stopAtBranchingNodes.has(current) && current !== branchNode) {
+      reachable.add(current);
+      continue;
+    }
+    if (allNodes.has(current)) {
+      reachable.add(current);
+      workflow.connections.forEach((conn) => {
+        const fromNode = conn.from.node;
+        const fromPort = conn.from.port;
+        const toNode = conn.to.node;
+        if (fromNode === current && !isSuccessPort(fromPort) && !isFailurePort(fromPort)) {
+          if (!visited.has(toNode)) {
+            queue.push(toNode);
+          }
+        }
+      });
+    }
+  }
+  return reachable;
+}
+function detectBranchingChains(branchingNodes, branchRegions) {
+  const chainSuccessor = /* @__PURE__ */ new Map();
+  for (const nodeId of branchingNodes) {
+    const region = branchRegions.get(nodeId);
+    if (!region) continue;
+    const successBranching = [...region.successNodes].filter((n) => branchingNodes.has(n));
+    const failureBranching = [...region.failureNodes].filter((n) => branchingNodes.has(n));
+    let nextNode = null;
+    if (successBranching.length === 1 && failureBranching.length === 0) {
+      nextNode = successBranching[0];
+    } else if (failureBranching.length === 1 && successBranching.length === 0) {
+      nextNode = failureBranching[0];
+    }
+    if (nextNode) {
+      chainSuccessor.set(nodeId, nextNode);
+    }
+  }
+  const hasChainPredecessor = new Set(chainSuccessor.values());
+  const chains = /* @__PURE__ */ new Map();
+  for (const nodeId of branchingNodes) {
+    if (hasChainPredecessor.has(nodeId)) continue;
+    if (!chainSuccessor.has(nodeId)) continue;
+    const chain = [nodeId];
+    let current = nodeId;
+    while (chainSuccessor.has(current)) {
+      const next = chainSuccessor.get(current);
+      chain.push(next);
+      current = next;
+    }
+    if (chain.length >= 2) {
+      chains.set(nodeId, chain);
+    }
+  }
+  return chains;
+}
+function computeParallelLevels(cfg, branchingNodes, scopedChildren) {
+  const inDegree = new Map(cfg.inDegree);
+  const queue = [];
+  const nodeLevel = /* @__PURE__ */ new Map();
+  inDegree.forEach((degree, node) => {
+    if (degree === 0) {
+      queue.push(node);
+      nodeLevel.set(node, 0);
+    }
+  });
+  while (queue.length > 0) {
+    const node = queue.shift();
+    const level = nodeLevel.get(node);
+    const successors = cfg.graph.get(node) || [];
+    for (const succ of successors) {
+      const newDeg = (inDegree.get(succ) || 0) - 1;
+      inDegree.set(succ, newDeg);
+      const currentLevel = nodeLevel.get(succ) ?? 0;
+      nodeLevel.set(succ, Math.max(currentLevel, level + 1));
+      if (newDeg === 0) {
+        queue.push(succ);
+      }
+    }
+  }
+  const levelGroups = /* @__PURE__ */ new Map();
+  nodeLevel.forEach((level, node) => {
+    if (isStartNode(node) || isExitNode(node)) return;
+    if (!levelGroups.has(level)) {
+      levelGroups.set(level, []);
+    }
+    levelGroups.get(level).push(node);
+  });
+  const sortedLevels = Array.from(levelGroups.keys()).sort((a, b) => a - b);
+  const result = [];
+  for (const level of sortedLevels) {
+    const nodes = levelGroups.get(level);
+    const parallelGroup = [];
+    for (const node of nodes) {
+      if (branchingNodes.has(node) || scopedChildren.has(node)) {
+        if (parallelGroup.length > 0) {
+          result.push([...parallelGroup]);
+          parallelGroup.length = 0;
+        }
+        result.push([node]);
+      } else {
+        parallelGroup.push(node);
+      }
+    }
+    if (parallelGroup.length > 0) {
+      result.push(parallelGroup);
+    }
+  }
+  return result;
+}
+
+// src/api/query.ts
+function getMainFlowConnections(ast) {
+  return ast.connections.filter((conn) => {
+    if (conn.from.scope || conn.to.scope) return false;
+    const fromInstance = ast.instances.find((i) => i.id === conn.from.node);
+    const toInstance = ast.instances.find((i) => i.id === conn.to.node);
+    if (fromInstance && isPerPortScopedChild(fromInstance, ast, ast.nodeTypes) || toInstance && isPerPortScopedChild(toInstance, ast, ast.nodeTypes)) {
+      return false;
+    }
+    return true;
+  });
+}
+function getMainFlowInstances(ast) {
+  return ast.instances.filter((inst) => !isPerPortScopedChild(inst, ast, ast.nodeTypes));
+}
+function getNode(ast, nodeId) {
+  return ast.instances.find((n) => n.id === nodeId);
+}
+function getNodes(ast, filter) {
+  let nodes = [...ast.instances];
+  if (!filter) {
+    return nodes;
+  }
+  if (filter.type) {
+    nodes = nodes.filter((n) => n.nodeType === filter.type);
+  }
+  if (filter.scope) {
+    nodes = nodes.filter((n) => {
+      if (!n.parent) return false;
+      return n.parent.id === filter.scope || n.parent.scope && `${n.parent.id}.${n.parent.scope}` === filter.scope;
+    });
+  }
+  if (filter.predicate) {
+    nodes = nodes.filter(filter.predicate);
+  }
+  return nodes;
+}
+function getConnections(ast, nodeId) {
+  if (!nodeId) {
+    return [...ast.connections];
+  }
+  return ast.connections.filter((conn) => conn.from.node === nodeId || conn.to.node === nodeId);
+}
+function getIncomingConnections(ast, nodeId, portName) {
+  return ast.connections.filter((conn) => {
+    if (conn.to.node !== nodeId) {
+      return false;
+    }
+    if (portName && conn.to.port !== portName) {
+      return false;
+    }
+    return true;
+  });
+}
+function getOutgoingConnections(ast, nodeId, portName) {
+  return ast.connections.filter((conn) => {
+    if (conn.from.node !== nodeId) {
+      return false;
+    }
+    if (portName && conn.from.port !== portName) {
+      return false;
+    }
+    return true;
+  });
+}
+function getDependencies(ast, nodeId) {
+  const deps = /* @__PURE__ */ new Set();
+  getMainFlowConnections(ast).forEach((conn) => {
+    if (conn.to.node === nodeId && conn.from.node !== "Start") {
+      deps.add(conn.from.node);
+    }
+  });
+  return Array.from(deps);
+}
+function getDataDependencies(ast, nodeId) {
+  const deps = /* @__PURE__ */ new Set();
+  const instanceTypeMap = /* @__PURE__ */ new Map();
+  for (const inst of ast.instances) {
+    const nt = ast.nodeTypes.find((t) => t.name === inst.nodeType || t.functionName === inst.nodeType);
+    if (nt) instanceTypeMap.set(inst.id, nt);
+  }
+  getMainFlowConnections(ast).forEach((conn) => {
+    if (conn.to.node === nodeId) {
+      if (conn.from.node === "Start") {
+        if (conn.from.port !== "execute") {
+          deps.add(conn.from.node);
+        }
+        return;
+      }
+      const sourceNodeType = instanceTypeMap.get(conn.from.node);
+      if (sourceNodeType) {
+        const sourcePort = sourceNodeType.outputs[conn.from.port];
+        if (sourcePort && (sourcePort.isControlFlow || sourcePort.dataType === "STEP")) {
+          return;
+        }
+      }
+      deps.add(conn.from.node);
+    }
+  });
+  return Array.from(deps);
+}
+function getDependents(ast, nodeId) {
+  const dependents = /* @__PURE__ */ new Set();
+  getMainFlowConnections(ast).forEach((conn) => {
+    if (conn.from.node === nodeId && conn.to.node !== "Exit") {
+      dependents.add(conn.to.node);
+    }
+  });
+  return Array.from(dependents);
+}
+function getTopologicalOrder(ast, options) {
+  const mainInstances = getMainFlowInstances(ast);
+  const mainConnections = getMainFlowConnections(ast);
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  mainInstances.forEach((node) => {
+    inDegree.set(node.id, 0);
+    adjacency.set(node.id, []);
+  });
+  mainConnections.forEach((conn) => {
+    if (conn.from.node !== "Start" && conn.to.node !== "Exit") {
+      const from = conn.from.node;
+      const to = conn.to.node;
+      adjacency.get(from)?.push(to);
+      inDegree.set(to, (inDegree.get(to) || 0) + 1);
+    }
+  });
+  const queue = [];
+  const result = [];
+  inDegree.forEach((degree, node) => {
+    if (degree === 0) {
+      queue.push(node);
+    }
+  });
+  while (queue.length > 0) {
+    const current = queue.shift();
+    result.push(current);
+    const neighbors = adjacency.get(current) || [];
+    neighbors.forEach((neighbor) => {
+      const newDegree = (inDegree.get(neighbor) || 0) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) {
+        queue.push(neighbor);
+      }
+    });
+  }
+  if (result.length !== mainInstances.length) {
+    throw new Error("Cannot compute topological order: workflow contains cycles");
+  }
+  if (options?.includeScopedChildren) {
+    const scopedChildren = ast.instances.filter(
+      (inst) => isPerPortScopedChild(inst, ast, ast.nodeTypes)
+    );
+    const expanded = [];
+    const scopedByParent = /* @__PURE__ */ new Map();
+    for (const child of scopedChildren) {
+      if (child.parent) {
+        const parentId = child.parent.id;
+        if (!scopedByParent.has(parentId)) {
+          scopedByParent.set(parentId, []);
+        }
+        scopedByParent.get(parentId).push(child.id);
+      }
+    }
+    for (const nodeId of result) {
+      expanded.push(nodeId);
+      const children = scopedByParent.get(nodeId);
+      if (children) {
+        expanded.push(...children);
+      }
+    }
+    return expanded;
+  }
+  return result;
+}
+function findIsolatedNodes(ast) {
+  const mainConnections = getMainFlowConnections(ast);
+  return getMainFlowInstances(ast).filter((node) => {
+    const hasConnections = mainConnections.some(
+      (conn) => conn.from.node === node.id || conn.to.node === node.id
+    );
+    return !hasConnections;
+  }).map((node) => node.id);
+}
+function findDeadEnds(ast) {
+  const deadEnds = [];
+  const mainConnections = getMainFlowConnections(ast);
+  getMainFlowInstances(ast).forEach((node) => {
+    const hasPathToExit = mainConnections.some((conn) => {
+      if (conn.from.node === node.id && conn.to.node === "Exit") {
+        return true;
+      }
+      const visited = /* @__PURE__ */ new Set();
+      const stack = [node.id];
+      while (stack.length > 0) {
+        const current = stack.pop();
+        if (visited.has(current)) {
+          continue;
+        }
+        visited.add(current);
+        const toExit = mainConnections.some((c) => c.from.node === current && c.to.node === "Exit");
+        if (toExit) {
+          return true;
+        }
+        const deps = getDependents(ast, current);
+        deps.forEach((dep) => stack.push(dep));
+      }
+      return false;
+    });
+    if (!hasPathToExit) {
+      deadEnds.push(node.id);
+    }
+  });
+  return deadEnds;
+}
+function findDeadEndDetails(ast) {
+  return {
+    deadEndNodes: findDeadEnds(ast),
+    disconnectedOutputs: findDisconnectedOutputPorts(ast)
+  };
+}
+function findDisconnectedOutputPorts(ast) {
+  const connectedOutputPorts = /* @__PURE__ */ new Set();
+  getMainFlowConnections(ast).forEach((conn) => {
+    connectedOutputPorts.add(`${conn.from.node}.${conn.from.port}`);
+  });
+  const results = [];
+  for (const instance of getMainFlowInstances(ast)) {
+    const nodeType = ast.nodeTypes.find((nt) => nt.name === instance.nodeType || nt.functionName === instance.nodeType);
+    if (!nodeType) continue;
+    const disconnectedPorts = [];
+    for (const [portName, portDef] of Object.entries(nodeType.outputs)) {
+      if (portDef.isControlFlow || portDef.failure || portDef.scope) continue;
+      if (!connectedOutputPorts.has(`${instance.id}.${portName}`)) {
+        disconnectedPorts.push(portName);
+      }
+    }
+    if (disconnectedPorts.length > 0) {
+      results.push({ nodeId: instance.id, ports: disconnectedPorts });
+    }
+  }
+  return results;
+}
+async function findWorkflows(directory, pattern) {
+  const files = await Ze(pattern ?? "**/*.ts", { cwd: directory, absolute: true });
+  const parser = new AnnotationParser();
+  const results = [];
+  for (const file of files) {
+    try {
+      const parseResult = parser.parse(file);
+      if (parseResult.workflows.length > 0) {
+        results.push({
+          filePath: file,
+          workflows: parseResult.workflows.map((w) => ({
+            name: w.name,
+            functionName: w.functionName,
+            nodeCount: w.instances.length,
+            connectionCount: w.connections.length
+          }))
+        });
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+
+export {
+  buildControlFlowGraph,
+  performKahnsTopologicalSort,
+  findAllBranchingNodes,
+  isPerPortScopedChild,
+  findNodesInBranch,
+  detectBranchingChains,
+  computeParallelLevels,
+  validatePortReference,
+  portReferencesEqual,
+  getNode,
+  getNodes,
+  getConnections,
+  getIncomingConnections,
+  getOutgoingConnections,
+  getDependencies,
+  getDataDependencies,
+  getDependents,
+  getTopologicalOrder,
+  findIsolatedNodes,
+  findDeadEndDetails,
+  findDisconnectedOutputPorts,
+  findWorkflows
+};