@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chunks/chunk-P2CVDGHR.js

@@ -0,0 +1,487 @@
+import {
+  AnnotationParser
+} from "./chunk-ZMGN6F3S.js";
+import {
+  Ze
+} from "./chunk-REEYC73I.js";
+import {
+  isPerPortScopedChild
+} from "./chunk-4EUSHAY6.js";
+
+// 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);
+}
+function formatPortReference(ref) {
+  return `${ref.node}.${ref.port}`;
+}
+
+// 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 getNodesByType(ast, nodeType) {
+  return ast.instances.filter((n) => n.nodeType === nodeType);
+}
+function getNodesInScope(ast, scopeName) {
+  return ast.instances.filter((n) => {
+    if (!n.parent) return false;
+    return n.parent.id === scopeName || n.parent.scope && `${n.parent.id}.${n.parent.scope}` === scopeName;
+  });
+}
+function hasNode(ast, nodeId) {
+  return ast.instances.some((n) => n.id === nodeId);
+}
+function findNodesByName(ast, pattern, caseSensitive = false) {
+  const regex = typeof pattern === "string" ? new RegExp(pattern, caseSensitive ? "" : "i") : pattern;
+  return ast.instances.filter((node) => {
+    if (regex.test(node.id)) {
+      return true;
+    }
+    if (node.config?.label && regex.test(node.config.label)) {
+      return true;
+    }
+    return false;
+  });
+}
+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 isConnected(ast, from, to) {
+  const fromRef = typeof from === "string" ? { node: from.split(".")[0], port: from.split(".")[1] } : from;
+  const toRef = typeof to === "string" ? { node: to.split(".")[0], port: to.split(".")[1] } : to;
+  return ast.connections.some(
+    (conn) => portReferencesEqual(conn.from, fromRef) && portReferencesEqual(conn.to, toRef)
+  );
+}
+function getConnectedPorts(ast, nodeId) {
+  const incoming = ast.connections.filter((conn) => conn.to.node === nodeId).map((conn) => conn.to);
+  const outgoing = ast.connections.filter((conn) => conn.from.node === nodeId).map((conn) => conn.from);
+  return { incoming, outgoing };
+}
+function getUnconnectedPorts(ast, nodeId) {
+  const node = ast.instances.find((n) => n.id === nodeId);
+  if (!node) {
+    return { inputs: [], outputs: [] };
+  }
+  const nodeType = ast.nodeTypes.find((nt) => nt.name === node.nodeType || nt.functionName === node.nodeType);
+  if (!nodeType) {
+    return { inputs: [], outputs: [] };
+  }
+  const connectedInputs = new Set(
+    ast.connections.filter((conn) => conn.to.node === nodeId).map((conn) => conn.to.port)
+  );
+  const connectedOutputs = new Set(
+    ast.connections.filter((conn) => conn.from.node === nodeId).map((conn) => conn.from.port)
+  );
+  const inputs = Object.keys(nodeType.inputs).filter((port) => !connectedInputs.has(port));
+  const outputs = Object.keys(nodeType.outputs).filter((port) => !connectedOutputs.has(port));
+  return { inputs, outputs };
+}
+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 getTransitiveDependencies(ast, nodeId) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [nodeId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    const deps = getDependencies(ast, current);
+    deps.forEach((dep) => {
+      if (!visited.has(dep)) {
+        queue.push(dep);
+      }
+    });
+  }
+  visited.delete(nodeId);
+  return Array.from(visited);
+}
+function findPath(ast, fromNodeId, toNodeId) {
+  if (fromNodeId === toNodeId) {
+    return [fromNodeId];
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [{ node: fromNodeId, path: [fromNodeId] }];
+  while (queue.length > 0) {
+    const { node: current, path } = queue.shift();
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    if (current === toNodeId) {
+      return path;
+    }
+    const dependents = getDependents(ast, current);
+    dependents.forEach((dep) => {
+      if (!visited.has(dep)) {
+        queue.push({ node: dep, path: [...path, dep] });
+      }
+    });
+  }
+  return null;
+}
+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 getExecutionGroups(ast) {
+  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 groups = [];
+  let currentLevel = Array.from(inDegree.entries()).filter(([_, degree]) => degree === 0).map(([node, _]) => node);
+  const processed = /* @__PURE__ */ new Set();
+  while (currentLevel.length > 0) {
+    groups.push([...currentLevel]);
+    const nextLevel = /* @__PURE__ */ new Set();
+    currentLevel.forEach((node) => {
+      processed.add(node);
+      const neighbors = adjacency.get(node) || [];
+      neighbors.forEach((neighbor) => {
+        const newDegree = (inDegree.get(neighbor) || 0) - 1;
+        inDegree.set(neighbor, newDegree);
+        if (newDegree === 0 && !processed.has(neighbor)) {
+          nextLevel.add(neighbor);
+        }
+      });
+    });
+    currentLevel = Array.from(nextLevel);
+  }
+  if (processed.size !== mainInstances.length) {
+    throw new Error("Cannot compute execution groups: workflow contains cycles");
+  }
+  return groups;
+}
+function countNodes(ast, filter) {
+  return getNodes(ast, filter).length;
+}
+function countConnections(ast, nodeId) {
+  return getConnections(ast, nodeId).length;
+}
+function countNodeTypes(ast) {
+  return ast.nodeTypes.length;
+}
+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 findUnusedNodeTypes(ast) {
+  const usedTypes = new Set(ast.instances.map((n) => n.nodeType));
+  return ast.nodeTypes.filter((nt) => !usedTypes.has(nt.functionName)).map((nt) => nt.name);
+}
+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 {
+  validatePortReference,
+  portReferencesEqual,
+  formatPortReference,
+  getNode,
+  getNodes,
+  getNodesByType,
+  getNodesInScope,
+  hasNode,
+  findNodesByName,
+  getConnections,
+  getIncomingConnections,
+  getOutgoingConnections,
+  isConnected,
+  getConnectedPorts,
+  getUnconnectedPorts,
+  getDependencies,
+  getDataDependencies,
+  getDependents,
+  getTransitiveDependencies,
+  findPath,
+  getTopologicalOrder,
+  getExecutionGroups,
+  countNodes,
+  countConnections,
+  countNodeTypes,
+  findIsolatedNodes,
+  findUnusedNodeTypes,
+  findDeadEnds,
+  findDeadEndDetails,
+  findDisconnectedOutputPorts,
+  findWorkflows
+};