@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-chunk-7ET6N32V.mjs

@@ -0,0 +1,419 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+
+// src/diff/WorkflowDiffer.ts
+function connectionKey(conn) {
+  return `${conn.from.node}:${conn.from.port}:${conn.from.scope ?? ""}->${conn.to.node}:${conn.to.port}:${conn.to.scope ?? ""}`;
+}
+function portDefinitionEquals(a, b) {
+  return a.dataType === b.dataType && a.tsType === b.tsType && a.optional === b.optional && JSON.stringify(a.default) === JSON.stringify(b.default) && a.expression === b.expression && a.scope === b.scope && a.mergeStrategy === b.mergeStrategy;
+}
+function comparePortMaps(beforePorts, afterPorts, direction) {
+  const changes = [];
+  const beforeKeys = new Set(Object.keys(beforePorts));
+  const afterKeys = new Set(Object.keys(afterPorts));
+  for (const key of afterKeys) {
+    if (!beforeKeys.has(key)) {
+      changes.push({
+        portName: key,
+        direction,
+        type: "ADDED",
+        after: afterPorts[key]
+      });
+    }
+  }
+  for (const key of beforeKeys) {
+    if (!afterKeys.has(key)) {
+      changes.push({
+        portName: key,
+        direction,
+        type: "REMOVED",
+        before: beforePorts[key]
+      });
+    }
+  }
+  for (const key of beforeKeys) {
+    if (afterKeys.has(key) && !portDefinitionEquals(beforePorts[key], afterPorts[key])) {
+      changes.push({
+        portName: key,
+        direction,
+        type: "MODIFIED",
+        before: beforePorts[key],
+        after: afterPorts[key]
+      });
+    }
+  }
+  return changes;
+}
+function compareNodeType(before, after) {
+  const changes = {};
+  let hasChanges = false;
+  if (before.functionName !== after.functionName) {
+    changes.functionName = { type: "MODIFIED", before: before.functionName, after: after.functionName };
+    hasChanges = true;
+  }
+  if (before.executeWhen !== after.executeWhen) {
+    changes.executeWhen = { type: "MODIFIED", before: before.executeWhen, after: after.executeWhen };
+    hasChanges = true;
+  }
+  if (before.branchingStrategy !== after.branchingStrategy) {
+    changes.branchingStrategy = { type: "MODIFIED", before: before.branchingStrategy, after: after.branchingStrategy };
+    hasChanges = true;
+  }
+  if (before.isAsync !== after.isAsync) {
+    changes.isAsync = { type: "MODIFIED", before: before.isAsync, after: after.isAsync };
+    hasChanges = true;
+  }
+  if (before.scope !== after.scope) {
+    changes.scope = { type: "MODIFIED", before: before.scope, after: after.scope };
+    hasChanges = true;
+  }
+  if (before.variant !== after.variant) {
+    changes.variant = { type: "MODIFIED", before: before.variant, after: after.variant };
+    hasChanges = true;
+  }
+  const inputChanges = comparePortMaps(before.inputs, after.inputs, "INPUT");
+  if (inputChanges.length > 0) {
+    changes.inputs = inputChanges;
+    hasChanges = true;
+  }
+  const outputChanges = comparePortMaps(before.outputs, after.outputs, "OUTPUT");
+  if (outputChanges.length > 0) {
+    changes.outputs = outputChanges;
+    hasChanges = true;
+  }
+  if (!hasChanges) return null;
+  return {
+    name: before.name,
+    changeType: "MODIFIED",
+    changes
+  };
+}
+function compareInstanceUI(beforeUI, afterUI) {
+  if (!beforeUI && !afterUI) return null;
+  const uiChanges = {};
+  let hasUIChanges = false;
+  const beforeLabel = beforeUI?.label ?? "";
+  const afterLabel = afterUI?.label ?? "";
+  if (beforeLabel !== afterLabel) {
+    uiChanges.label = { type: "MODIFIED", before: beforeLabel, after: afterLabel };
+    hasUIChanges = true;
+  }
+  const beforeWidth = beforeUI?.width ?? 0;
+  const beforeHeight = beforeUI?.height ?? 0;
+  const afterWidth = afterUI?.width ?? 0;
+  const afterHeight = afterUI?.height ?? 0;
+  if (beforeWidth !== afterWidth || beforeHeight !== afterHeight) {
+    uiChanges.size = {
+      type: "MODIFIED",
+      before: { width: beforeWidth, height: beforeHeight },
+      after: { width: afterWidth, height: afterHeight }
+    };
+    hasUIChanges = true;
+  }
+  const beforeMinimized = beforeUI?.minimized ?? false;
+  const afterMinimized = afterUI?.minimized ?? false;
+  if (beforeMinimized !== afterMinimized) {
+    uiChanges.minimized = { type: "MODIFIED", before: beforeMinimized, after: afterMinimized };
+    hasUIChanges = true;
+  }
+  return hasUIChanges ? uiChanges : null;
+}
+function compareInstance(before, after, beforeUI, afterUI) {
+  const changes = {};
+  let hasChanges = false;
+  if (before.nodeType !== after.nodeType) {
+    changes.nodeType = { type: "MODIFIED", before: before.nodeType, after: after.nodeType };
+    hasChanges = true;
+  }
+  const beforeParent = before.parent ?? null;
+  const afterParent = after.parent ?? null;
+  if (JSON.stringify(beforeParent) !== JSON.stringify(afterParent)) {
+    changes.parent = { type: "MODIFIED", before: beforeParent, after: afterParent };
+    hasChanges = true;
+  }
+  const beforeConfig = before.config;
+  const afterConfig = after.config;
+  const configChanges = {};
+  let hasConfigChanges = false;
+  const beforePullExec = beforeConfig?.pullExecution;
+  const afterPullExec = afterConfig?.pullExecution;
+  if (JSON.stringify(beforePullExec) !== JSON.stringify(afterPullExec)) {
+    configChanges.pullExecution = { type: "MODIFIED", before: beforePullExec, after: afterPullExec };
+    hasConfigChanges = true;
+  }
+  const beforePortConfigs = beforeConfig?.portConfigs;
+  const afterPortConfigs = afterConfig?.portConfigs;
+  if (JSON.stringify(beforePortConfigs) !== JSON.stringify(afterPortConfigs)) {
+    configChanges.portConfigs = { type: "MODIFIED", before: beforePortConfigs, after: afterPortConfigs };
+    hasConfigChanges = true;
+  }
+  if (hasConfigChanges) {
+    changes.config = configChanges;
+    hasChanges = true;
+  }
+  const uiChanges = compareInstanceUI(beforeUI, afterUI);
+  if (uiChanges) {
+    changes.ui = uiChanges;
+    hasChanges = true;
+  }
+  if (!hasChanges) return null;
+  return {
+    id: before.id,
+    changeType: "MODIFIED",
+    changes
+  };
+}
+function compareWorkflowPorts(beforePorts, afterPorts) {
+  const result = {
+    added: [],
+    removed: [],
+    modified: []
+  };
+  const beforeKeys = new Set(Object.keys(beforePorts));
+  const afterKeys = new Set(Object.keys(afterPorts));
+  for (const key of afterKeys) {
+    if (!beforeKeys.has(key)) {
+      result.added.push({ name: key, definition: afterPorts[key] });
+    }
+  }
+  for (const key of beforeKeys) {
+    if (!afterKeys.has(key)) {
+      result.removed.push({ name: key, definition: beforePorts[key] });
+    }
+  }
+  for (const key of beforeKeys) {
+    if (afterKeys.has(key) && !portDefinitionEquals(beforePorts[key], afterPorts[key])) {
+      result.modified.push({
+        name: key,
+        before: beforePorts[key],
+        after: afterPorts[key]
+      });
+    }
+  }
+  return result;
+}
+function calculateImpact(diff) {
+  const criticalConnections = diff.connections.some(
+    (c) => c.changeType === "REMOVED" && (c.from.node === "Start" || c.to.node === "Exit")
+  );
+  if (criticalConnections) return "CRITICAL";
+  if (diff.startPorts.removed.length > 0 || diff.exitPorts.removed.length > 0) {
+    return "CRITICAL";
+  }
+  if (diff.summary.nodeTypesRemoved > 0 || diff.summary.instancesRemoved > 0 || diff.summary.connectionsRemoved > 0) {
+    return "BREAKING";
+  }
+  const hasBreakingPortChanges = diff.nodeTypes.some((nt) => {
+    const inputChanges = nt.changes.inputs?.some((p) => p.type === "REMOVED" || p.type === "MODIFIED" && p.before?.dataType !== p.after?.dataType);
+    const outputChanges = nt.changes.outputs?.some((p) => p.type === "REMOVED" || p.type === "MODIFIED" && p.before?.dataType !== p.after?.dataType);
+    return inputChanges || outputChanges;
+  });
+  if (hasBreakingPortChanges) return "BREAKING";
+  if (diff.summary.nodeTypesAdded > 0 || diff.summary.instancesAdded > 0 || diff.summary.connectionsAdded > 0 || diff.startPorts.added.length > 0 || diff.exitPorts.added.length > 0) {
+    return "MINOR";
+  }
+  if (diff.summary.nodeTypesModified > 0 || diff.summary.instancesModified > 0) {
+    return "MINOR";
+  }
+  return "COSMETIC";
+}
+var WorkflowDiffer = class {
+  /**
+   * Compare two workflows and return semantic diff
+   */
+  static compare(before, after) {
+    const nodeTypes = [];
+    const instances = [];
+    const connections = [];
+    const scopes = [];
+    const beforeNodeTypes = new Map(before.nodeTypes.map((nt) => [nt.name, nt]));
+    const afterNodeTypes = new Map(after.nodeTypes.map((nt) => [nt.name, nt]));
+    const beforeInstances = new Map(before.instances.map((i) => [i.id, i]));
+    const afterInstances = new Map(after.instances.map((i) => [i.id, i]));
+    const beforeConnections = new Map(before.connections.map((c) => [connectionKey(c), c]));
+    const afterConnections = new Map(after.connections.map((c) => [connectionKey(c), c]));
+    const beforeScopes = before.scopes ?? {};
+    const afterScopes = after.scopes ?? {};
+    const beforeUIInstances = new Map(
+      (before.ui?.instances ?? []).map((ui) => [ui.name, ui])
+    );
+    const afterUIInstances = new Map(
+      (after.ui?.instances ?? []).map((ui) => [ui.name, ui])
+    );
+    for (const [name, nt] of afterNodeTypes) {
+      if (!beforeNodeTypes.has(name)) {
+        nodeTypes.push({ name, changeType: "ADDED", changes: {} });
+      } else {
+        const diff = compareNodeType(beforeNodeTypes.get(name), nt);
+        if (diff) nodeTypes.push(diff);
+      }
+    }
+    for (const [name] of beforeNodeTypes) {
+      if (!afterNodeTypes.has(name)) {
+        nodeTypes.push({ name, changeType: "REMOVED", changes: {} });
+      }
+    }
+    for (const [id, inst] of afterInstances) {
+      if (!beforeInstances.has(id)) {
+        instances.push({ id, changeType: "ADDED", changes: {} });
+      } else {
+        const diff = compareInstance(
+          beforeInstances.get(id),
+          inst,
+          beforeUIInstances.get(id),
+          afterUIInstances.get(id)
+        );
+        if (diff) instances.push(diff);
+      }
+    }
+    for (const [id] of beforeInstances) {
+      if (!afterInstances.has(id)) {
+        instances.push({ id, changeType: "REMOVED", changes: {} });
+      }
+    }
+    for (const [key, conn] of afterConnections) {
+      if (!beforeConnections.has(key)) {
+        connections.push({
+          changeType: "ADDED",
+          from: { node: conn.from.node, port: conn.from.port, scope: conn.from.scope },
+          to: { node: conn.to.node, port: conn.to.port, scope: conn.to.scope }
+        });
+      }
+    }
+    for (const [key, conn] of beforeConnections) {
+      if (!afterConnections.has(key)) {
+        connections.push({
+          changeType: "REMOVED",
+          from: { node: conn.from.node, port: conn.from.port, scope: conn.from.scope },
+          to: { node: conn.to.node, port: conn.to.port, scope: conn.to.scope }
+        });
+      }
+    }
+    const allScopeNames = /* @__PURE__ */ new Set([...Object.keys(beforeScopes), ...Object.keys(afterScopes)]);
+    for (const name of allScopeNames) {
+      const beforeMembers = beforeScopes[name];
+      const afterMembers = afterScopes[name];
+      if (!beforeMembers) {
+        scopes.push({ name, changeType: "ADDED", after: afterMembers });
+      } else if (!afterMembers) {
+        scopes.push({ name, changeType: "REMOVED", before: beforeMembers });
+      } else if (JSON.stringify(beforeMembers.sort()) !== JSON.stringify(afterMembers.sort())) {
+        scopes.push({ name, changeType: "MODIFIED", before: beforeMembers, after: afterMembers });
+      }
+    }
+    const startPorts = compareWorkflowPorts(before.startPorts, after.startPorts);
+    const exitPorts = compareWorkflowPorts(before.exitPorts, after.exitPorts);
+    const modifiedInstances = instances.filter((i) => i.changeType === "MODIFIED");
+    const summary = {
+      nodeTypesAdded: nodeTypes.filter((nt) => nt.changeType === "ADDED").length,
+      nodeTypesRemoved: nodeTypes.filter((nt) => nt.changeType === "REMOVED").length,
+      nodeTypesModified: nodeTypes.filter((nt) => nt.changeType === "MODIFIED").length,
+      instancesAdded: instances.filter((i) => i.changeType === "ADDED").length,
+      instancesRemoved: instances.filter((i) => i.changeType === "REMOVED").length,
+      instancesModified: modifiedInstances.filter(
+        (i) => i.changes.nodeType || i.changes.config || i.changes.parent
+      ).length,
+      instancesUIModified: modifiedInstances.filter((i) => i.changes.ui).length,
+      connectionsAdded: connections.filter((c) => c.changeType === "ADDED").length,
+      connectionsRemoved: connections.filter((c) => c.changeType === "REMOVED").length
+    };
+    const identical = nodeTypes.length === 0 && instances.length === 0 && connections.length === 0 && scopes.length === 0 && startPorts.added.length === 0 && startPorts.removed.length === 0 && startPorts.modified.length === 0 && exitPorts.added.length === 0 && exitPorts.removed.length === 0 && exitPorts.modified.length === 0;
+    const partialDiff = {
+      identical,
+      summary,
+      nodeTypes,
+      instances,
+      connections,
+      startPorts,
+      exitPorts,
+      scopes
+    };
+    return {
+      ...partialDiff,
+      impact: identical ? "COSMETIC" : calculateImpact(partialDiff)
+    };
+  }
+};
+
+// src/diff/impact.ts
+var IMPACT_DESCRIPTIONS = {
+  CRITICAL: "Workflow API changed - consumers must update",
+  BREAKING: "Internal structure changed - may break dependent workflows",
+  MINOR: "Additions or non-breaking modifications",
+  COSMETIC: "No semantic changes"
+};
+function getImpactReasons(diff) {
+  const reasons = [];
+  if (diff.identical) {
+    reasons.push("Workflows are semantically identical");
+    return reasons;
+  }
+  if (diff.startPorts.removed.length > 0) {
+    reasons.push(`Removed ${diff.startPorts.removed.length} workflow input port(s): ${diff.startPorts.removed.map((p) => p.name).join(", ")}`);
+  }
+  if (diff.exitPorts.removed.length > 0) {
+    reasons.push(`Removed ${diff.exitPorts.removed.length} workflow output port(s): ${diff.exitPorts.removed.map((p) => p.name).join(", ")}`);
+  }
+  if (diff.summary.nodeTypesRemoved > 0) {
+    const removed = diff.nodeTypes.filter((nt) => nt.changeType === "REMOVED");
+    reasons.push(`Removed ${removed.length} node type(s): ${removed.map((nt) => nt.name).join(", ")}`);
+  }
+  if (diff.summary.instancesRemoved > 0) {
+    const removed = diff.instances.filter((i) => i.changeType === "REMOVED");
+    reasons.push(`Removed ${removed.length} instance(s): ${removed.map((i) => i.id).join(", ")}`);
+  }
+  if (diff.summary.connectionsRemoved > 0) {
+    reasons.push(`Removed ${diff.summary.connectionsRemoved} connection(s)`);
+  }
+  for (const nt of diff.nodeTypes) {
+    const removedInputs = nt.changes.inputs?.filter((p) => p.type === "REMOVED") ?? [];
+    const removedOutputs = nt.changes.outputs?.filter((p) => p.type === "REMOVED") ?? [];
+    if (removedInputs.length > 0) {
+      reasons.push(`Node type '${nt.name}' removed input port(s): ${removedInputs.map((p) => p.portName).join(", ")}`);
+    }
+    if (removedOutputs.length > 0) {
+      reasons.push(`Node type '${nt.name}' removed output port(s): ${removedOutputs.map((p) => p.portName).join(", ")}`);
+    }
+  }
+  if (diff.summary.nodeTypesAdded > 0) {
+    const added = diff.nodeTypes.filter((nt) => nt.changeType === "ADDED");
+    reasons.push(`Added ${added.length} node type(s): ${added.map((nt) => nt.name).join(", ")}`);
+  }
+  if (diff.summary.instancesAdded > 0) {
+    const added = diff.instances.filter((i) => i.changeType === "ADDED");
+    reasons.push(`Added ${added.length} instance(s): ${added.map((i) => i.id).join(", ")}`);
+  }
+  if (diff.summary.connectionsAdded > 0) {
+    reasons.push(`Added ${diff.summary.connectionsAdded} connection(s)`);
+  }
+  if (diff.startPorts.added.length > 0) {
+    reasons.push(`Added workflow input port(s): ${diff.startPorts.added.map((p) => p.name).join(", ")}`);
+  }
+  if (diff.exitPorts.added.length > 0) {
+    reasons.push(`Added workflow output port(s): ${diff.exitPorts.added.map((p) => p.name).join(", ")}`);
+  }
+  if (diff.summary.nodeTypesModified > 0) {
+    const modified = diff.nodeTypes.filter((nt) => nt.changeType === "MODIFIED");
+    reasons.push(`Modified ${modified.length} node type(s): ${modified.map((nt) => nt.name).join(", ")}`);
+  }
+  if (diff.summary.instancesModified > 0) {
+    const modified = diff.instances.filter((i) => i.changeType === "MODIFIED");
+    reasons.push(`Modified ${modified.length} instance(s): ${modified.map((i) => i.id).join(", ")}`);
+  }
+  if (diff.scopes.length > 0) {
+    const added = diff.scopes.filter((s) => s.changeType === "ADDED").map((s) => s.name);
+    const removed = diff.scopes.filter((s) => s.changeType === "REMOVED").map((s) => s.name);
+    const modified = diff.scopes.filter((s) => s.changeType === "MODIFIED").map((s) => s.name);
+    if (added.length > 0) reasons.push(`Added scope(s): ${added.join(", ")}`);
+    if (removed.length > 0) reasons.push(`Removed scope(s): ${removed.join(", ")}`);
+    if (modified.length > 0) reasons.push(`Modified scope(s): ${modified.join(", ")}`);
+  }
+  return reasons;
+}
+
+export {
+  WorkflowDiffer,
+  IMPACT_DESCRIPTIONS,
+  getImpactReasons
+};