@foresthubai/workflow-builder 0.4.3 → 0.4.5

package/src/utils/categoryConstants.ts

@@ -1,26 +1,30 @@
-// Shared category icons and colors for node categories in the workflow builder.
-
-import { NodeCategory } from "@foresthubai/workflow-core/node";
-import { Bot, Box, Brain, Inbox, Send, Variable, Wrench, Zap, type LucideIcon } from "lucide-react";
-
-export const categoryIcons: Record<string, LucideIcon> = {
-  [NodeCategory.Input]: Inbox,
-  [NodeCategory.Logic]: Brain,
-  [NodeCategory.Data]: Variable,
-  [NodeCategory.Output]: Send,
-  [NodeCategory.AI]: Bot,
-  [NodeCategory.Trigger]: Zap,
-  [NodeCategory.Tool]: Wrench,
-  [NodeCategory.Function]: Box,
-};
-
-export const categoryColors: Record<string, string> = {
-  [NodeCategory.Input]: "bg-node-input/10 text-node-input border-node-input/20",
-  [NodeCategory.Logic]: "bg-node-logic/10 text-node-logic border-node-logic/20",
-  [NodeCategory.Data]: "bg-node-data/10 text-node-data border-node-data/20",
-  [NodeCategory.Output]: "bg-node-output/10 text-node-output border-node-output/20",
-  [NodeCategory.AI]: "bg-node-agent/10 text-node-agent border-node-agent/20",
-  [NodeCategory.Trigger]: "bg-node-trigger/10 text-node-trigger border-node-trigger/20",
-  [NodeCategory.Tool]: "bg-node-tool/10 text-node-tool border-node-tool/20",
-  [NodeCategory.Function]: "bg-node-function/10 text-node-function border-node-function/20",
-};
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 ForestHub. All rights reserved.
+// For commercial licensing, contact root@foresthub.ai
+
+// Shared category icons and colors for node categories in the workflow builder.
+
+import { NodeCategory } from "@foresthubai/workflow-core/node";
+import { Bot, Box, Brain, Inbox, Send, Variable, Wrench, Zap, type LucideIcon } from "lucide-react";
+
+export const categoryIcons: Record<string, LucideIcon> = {
+  [NodeCategory.Input]: Inbox,
+  [NodeCategory.Logic]: Brain,
+  [NodeCategory.Data]: Variable,
+  [NodeCategory.Output]: Send,
+  [NodeCategory.AI]: Bot,
+  [NodeCategory.Trigger]: Zap,
+  [NodeCategory.Tool]: Wrench,
+  [NodeCategory.Function]: Box,
+};
+
+export const categoryColors: Record<string, string> = {
+  [NodeCategory.Input]: "bg-node-input/10 text-node-input border-node-input/20",
+  [NodeCategory.Logic]: "bg-node-logic/10 text-node-logic border-node-logic/20",
+  [NodeCategory.Data]: "bg-node-data/10 text-node-data border-node-data/20",
+  [NodeCategory.Output]: "bg-node-output/10 text-node-output border-node-output/20",
+  [NodeCategory.AI]: "bg-node-agent/10 text-node-agent border-node-agent/20",
+  [NodeCategory.Trigger]: "bg-node-trigger/10 text-node-trigger border-node-trigger/20",
+  [NodeCategory.Tool]: "bg-node-tool/10 text-node-tool border-node-tool/20",
+  [NodeCategory.Function]: "bg-node-function/10 text-node-function border-node-function/20",
+};

package/src/utils/channelOperations.ts

@@ -1,86 +1,90 @@
-import { CHANNEL_DEFINITION, type ChannelType, type Channel } from "@foresthubai/workflow-core/channel";
-import { isParameterActive } from "@foresthubai/workflow-core/parameter";
-import { useEditorStore } from "../stores/editorStore";
-import { generateId } from "@foresthubai/workflow-core/id";
-import { uniqueName } from "./resourceHelpers";
-
-/**
- * Build the initial `arguments` record for a new channel: each parameter
- * that's active for the chosen `type` and has a `default` gets seeded.
- */
-function defaultArguments(type: ChannelType): Record<string, unknown> {
-  const seed: Record<string, unknown> = { type };
-  const args: Record<string, unknown> = {};
-  for (const param of CHANNEL_DEFINITION.parameters) {
-    if (param.id === "type") continue;
-    if (param.activationRules?.length && !isParameterActive(param, seed, false)) continue;
-    if ("default" in param && param.default !== undefined) {
-      args[param.id] = param.default;
-    }
-  }
-  return args;
-}
-
-/**
- * Create a new channel in the editor store. Returns the new instance.
- */
-export function addChannel(type: ChannelType = "GPIOIN"): Channel {
-  const id = generateId();
-  const existing = Object.values(useEditorStore.getState().channels).map((v) => v.label);
-  const instance: Channel = {
-    id,
-    label: uniqueName("channel", existing),
-    type,
-    arguments: defaultArguments(type),
-  };
-  useEditorStore.getState().setChannels((vars) => ({ ...vars, [id]: instance }));
-  return instance;
-}
-
-/**
- * Apply a partial patch to a channel. Inactive arguments are intentionally
- * retained in the store: the domain store is the superset and stripping happens
- * only at the api boundary (`serialize`), so switching `type` away and back
- * restores previously-entered values rather than resetting them. On a type
- * change we still seed defaults for params that are newly active and unset, so
- * the config panel shows sensible initial values. Top-level fields (label/type)
- * are merged separately from arguments.
- */
-export function updateChannel(id: string, patch: { label?: string; type?: ChannelType; arguments?: Record<string, unknown> }): void {
-  const key = id;
-  useEditorStore.getState().setChannels((vars) => {
-    const existing = vars[key];
-    if (!existing) return vars;
-
-    const nextType = patch.type ?? existing.type;
-    const mergedArgs = { ...existing.arguments, ...(patch.arguments ?? {}) };
-
-    if (patch.type && patch.type !== existing.type) {
-      for (const [k, v] of Object.entries(defaultArguments(nextType))) {
-        if (mergedArgs[k] === undefined) mergedArgs[k] = v;
-      }
-    }
-
-    return {
-      ...vars,
-      [key]: {
-        ...existing,
-        ...(patch.label !== undefined ? { label: patch.label } : {}),
-        type: nextType,
-        arguments: mergedArgs,
-      },
-    };
-  });
-}
-
-export function deleteChannel(id: string): void {
-  const key = id;
-  useEditorStore.getState().setChannels((vars) => {
-    const { [key]: _drop, ...rest } = vars;
-    return rest;
-  });
-  const sel = useEditorStore.getState().selection;
-  if (sel.kind === "channel" && sel.id === id) {
-    useEditorStore.getState().clearSelection();
-  }
-}
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 ForestHub. All rights reserved.
+// For commercial licensing, contact root@foresthub.ai
+
+import { CHANNEL_DEFINITION, type ChannelType, type Channel } from "@foresthubai/workflow-core/channel";
+import { isParameterActive } from "@foresthubai/workflow-core/parameter";
+import { useEditorStore } from "../stores/editorStore";
+import { generateId } from "@foresthubai/workflow-core/id";
+import { uniqueName } from "./resourceHelpers";
+
+/**
+ * Build the initial `arguments` record for a new channel: each parameter
+ * that's active for the chosen `type` and has a `default` gets seeded.
+ */
+function defaultArguments(type: ChannelType): Record<string, unknown> {
+  const seed: Record<string, unknown> = { type };
+  const args: Record<string, unknown> = {};
+  for (const param of CHANNEL_DEFINITION.parameters) {
+    if (param.id === "type") continue;
+    if (param.activationRules?.length && !isParameterActive(param, seed, false)) continue;
+    if ("default" in param && param.default !== undefined) {
+      args[param.id] = param.default;
+    }
+  }
+  return args;
+}
+
+/**
+ * Create a new channel in the editor store. Returns the new instance.
+ */
+export function addChannel(type: ChannelType = "GPIOIN"): Channel {
+  const id = generateId();
+  const existing = Object.values(useEditorStore.getState().channels).map((v) => v.label);
+  const instance: Channel = {
+    id,
+    label: uniqueName("channel", existing),
+    type,
+    arguments: defaultArguments(type),
+  };
+  useEditorStore.getState().setChannels((vars) => ({ ...vars, [id]: instance }));
+  return instance;
+}
+
+/**
+ * Apply a partial patch to a channel. Inactive arguments are intentionally
+ * retained in the store: the domain store is the superset and stripping happens
+ * only at the api boundary (`serialize`), so switching `type` away and back
+ * restores previously-entered values rather than resetting them. On a type
+ * change we still seed defaults for params that are newly active and unset, so
+ * the config panel shows sensible initial values. Top-level fields (label/type)
+ * are merged separately from arguments.
+ */
+export function updateChannel(id: string, patch: { label?: string; type?: ChannelType; arguments?: Record<string, unknown> }): void {
+  const key = id;
+  useEditorStore.getState().setChannels((vars) => {
+    const existing = vars[key];
+    if (!existing) return vars;
+
+    const nextType = patch.type ?? existing.type;
+    const mergedArgs = { ...existing.arguments, ...(patch.arguments ?? {}) };
+
+    if (patch.type && patch.type !== existing.type) {
+      for (const [k, v] of Object.entries(defaultArguments(nextType))) {
+        if (mergedArgs[k] === undefined) mergedArgs[k] = v;
+      }
+    }
+
+    return {
+      ...vars,
+      [key]: {
+        ...existing,
+        ...(patch.label !== undefined ? { label: patch.label } : {}),
+        type: nextType,
+        arguments: mergedArgs,
+      },
+    };
+  });
+}
+
+export function deleteChannel(id: string): void {
+  const key = id;
+  useEditorStore.getState().setChannels((vars) => {
+    const { [key]: _drop, ...rest } = vars;
+    return rest;
+  });
+  const sel = useEditorStore.getState().selection;
+  if (sel.kind === "channel" && sel.id === id) {
+    useEditorStore.getState().clearSelection();
+  }
+}

package/src/utils/connectionRules.ts

@@ -1,137 +1,140 @@
-// Editor connection rules — which ports may connect, which node types are
-// offered from a port, and whether a node can take another outgoing edge.
-//
-// These operate on React Flow `Node`/`Edge` and drive canvas interactions, so
-// they live here in the editor rather than in the headless @foresthubai/workflow-core.
-// Core exposes the pure primitive (`getPorts`); the React Flow coupling stays
-// on this side of the boundary.
-
-import { Edge, Node } from "@xyflow/react";
-import { getPorts, NodeRegistry, type NodeData, type NodeDefinition } from "@foresthubai/workflow-core/node";
-import { type EdgeType } from "@foresthubai/workflow-core/edge";
-
-/** Check whether a node already has tool-input edges (for mutual exclusion). */
-function hasToolInputEdge(nodeId: string, nodeData: NodeData, edges: Edge[]): boolean {
-  const ports = getPorts(nodeData);
-  return edges.some((e) => e.target === nodeId && ports.input.some((p) => p.type === "tool" && p.id === e.targetHandle));
-}
-
-/** Check whether a node already has control-flow edges (for mutual exclusion). */
-function hasControlFlowEdge(nodeId: string, nodeData: NodeData, edges: Edge[]): boolean {
-  const ports = getPorts(nodeData);
-  return edges.some((e) => {
-    if (e.target === nodeId) {
-      return ports.input.some((p) => p.type === "control" && p.id === e.targetHandle);
-    }
-    if (e.source === nodeId) {
-      return ports.output.some((p) => p.type === "control" && p.id === e.sourceHandle);
-    }
-    return false;
-  });
-}
-
-/**
- * Check whether an output port can accept at least one more outgoing edge.
- * Used by the contextual "+" button on output ports.
- */
-export function canPortAcceptEdge(nodeId: string, handleId: string, nodes: Node<NodeData>[], edges: Edge[]): boolean {
-  const node = nodes.find((n) => n.id === nodeId);
-  if (!node) return false;
-
-  const ports = getPorts(node.data);
-  const port = ports.output.find((p) => p.id === handleId);
-  if (!port) return false;
-
-  // Tool output ports always accept multiple edges (an agent wires up many tools).
-  // A control output port accepts a single edge unless the node can branch.
-  if (port.type === "control" && !NodeRegistry.getByType(node.data.type)?.canBranch) {
-    if (edges.some((e) => e.source === nodeId && e.sourceHandle === handleId)) return false;
-  }
-
-  // Mutual exclusion: control output blocked when node has tool-input edges
-  // (Tool output is exempt — never blocked)
-  if (port.type === "control" && hasToolInputEdge(nodeId, node.data, edges)) return false;
-
-  return true;
-}
-
-/**
- * Filter node definitions to those that can connect to a given output port.
- * Returns definitions whose nodes have an input port matching the origin's port type.
- */
-export function getCompatibleNodeDefs(
-  originNodeId: string,
-  originHandleId: string,
-  nodes: Node<NodeData>[],
-  edges: Edge[],
-  allNodeDefs: NodeDefinition[],
-  isFunctionCanvas: boolean,
-): NodeDefinition[] {
-  const originNode = nodes.find((n) => n.id === originNodeId);
-  if (!originNode) return [];
-
-  const originPorts = getPorts(originNode.data);
-  const originPort = originPorts.output.find((p) => p.id === originHandleId);
-  if (!originPort) return [];
-
-  const originPortType = originPort.type; // "control" | "tool"
-
-  return allNodeDefs.filter((def) => {
-    if (def.isUnremovable) return false;
-
-    if (def.isSingleton && nodes.some((n) => n.data.type === def.type)) return false;
-
-    // Triggers have no inputs — skip on function canvas and when looking for input ports
-    if (isFunctionCanvas && def.category === "Trigger") return false;
-
-    // Check candidate has a matching input port
-    const candidatePorts = getPorts({ type: def.type } as NodeData);
-    return candidatePorts.input.some((p) => p.type === originPortType);
-  });
-}
-
-export const isValidConnection = (
-  sourceId: string | null,
-  targetId: string | null,
-  sourceHandleId: string | null | undefined,
-  targetHandleId: string | null | undefined,
-  nodes: Node<NodeData>[],
-  edges: Edge[],
-): false | EdgeType => {
-  // All handles must be present
-  if (sourceHandleId == null || targetHandleId == null || sourceId == null || targetId == null) return false;
-
-  // Find source and target nodes
-  const srcNode = nodes.find((n) => n.id === sourceId);
-  const tgtNode = nodes.find((n) => n.id === targetId);
-  if (!srcNode || !tgtNode) return false;
-
-  // Source-side checks via canPortAcceptEdge (multiple-outgoing + mutual exclusion)
-  if (!canPortAcceptEdge(sourceId, sourceHandleId, nodes, edges)) return false;
-
-  // Get ports using centralized dispatcher
-  const sourcePorts = getPorts(srcNode.data);
-  const targetPorts = getPorts(tgtNode.data);
-
-  const sourcePort = sourcePorts.output.find((p) => p.id === sourceHandleId);
-  const targetPort = targetPorts.input.find((p) => p.id === targetHandleId);
-  if (!sourcePort || !targetPort) return false;
-
-  // Only allow connections between same port types
-  if (sourcePort.type !== targetPort.type) return false;
-
-  // Target-side mutual exclusion checks
-  const portType = sourcePort.type as EdgeType;
-
-  if (portType === "tool") {
-    // Connecting a tool input on the target — reject if target already has control connections
-    if (hasControlFlowEdge(tgtNode.id, tgtNode.data, edges)) return false;
-  }
-
-  if (portType === "control") {
-    // Connecting a control port — reject if target already has tool INPUT connections
-    if (hasToolInputEdge(tgtNode.id, tgtNode.data, edges)) return false;
-  }
-
-  return portType;
-};
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 ForestHub. All rights reserved.
+// For commercial licensing, contact root@foresthub.ai
+
+// Editor connection rules — which ports may connect, which node types are
+// offered from a port, and whether a node can take another outgoing edge.
+//
+// These operate on React Flow `Node`/`Edge` and drive canvas interactions, so
+// they live here in the editor rather than in the headless @foresthubai/workflow-core.
+// Core exposes the pure primitive (`getPorts`); the React Flow coupling stays
+// on this side of the boundary.
+
+import { Edge, Node } from "@xyflow/react";
+import { getPorts, NodeRegistry, type NodeData, type NodeDefinition } from "@foresthubai/workflow-core/node";
+import { type EdgeType } from "@foresthubai/workflow-core/edge";
+
+/** Check whether a node already has tool-input edges (for mutual exclusion). */
+function hasToolInputEdge(nodeId: string, nodeData: NodeData, edges: Edge[]): boolean {
+  const ports = getPorts(nodeData);
+  return edges.some((e) => e.target === nodeId && ports.input.some((p) => p.type === "tool" && p.id === e.targetHandle));
+}
+
+/** Check whether a node already has control-flow edges (for mutual exclusion). */
+function hasControlFlowEdge(nodeId: string, nodeData: NodeData, edges: Edge[]): boolean {
+  const ports = getPorts(nodeData);
+  return edges.some((e) => {
+    if (e.target === nodeId) {
+      return ports.input.some((p) => p.type === "control" && p.id === e.targetHandle);
+    }
+    if (e.source === nodeId) {
+      return ports.output.some((p) => p.type === "control" && p.id === e.sourceHandle);
+    }
+    return false;
+  });
+}
+
+/**
+ * Check whether an output port can accept at least one more outgoing edge.
+ * Used by the contextual "+" button on output ports.
+ * Takes the node's own data rather than the nodes array so per-node components
+ * (BaseNode) can call it without subscribing to all nodes.
+ */
+export function canPortAcceptEdge(nodeData: NodeData, handleId: string, edges: Edge[]): boolean {
+  const ports = getPorts(nodeData);
+  const port = ports.output.find((p) => p.id === handleId);
+  if (!port) return false;
+
+  // Tool output ports always accept multiple edges (an agent wires up many tools).
+  // A control output port accepts a single edge unless the node can branch.
+  if (port.type === "control" && !NodeRegistry.getByType(nodeData.type)?.canBranch) {
+    if (edges.some((e) => e.source === nodeData.id && e.sourceHandle === handleId)) return false;
+  }
+
+  // Mutual exclusion: control output blocked when node has tool-input edges
+  // (Tool output is exempt — never blocked)
+  if (port.type === "control" && hasToolInputEdge(nodeData.id, nodeData, edges)) return false;
+
+  return true;
+}
+
+/**
+ * Filter node definitions to those that can connect to a given output port.
+ * Returns definitions whose nodes have an input port matching the origin's port type.
+ */
+export function getCompatibleNodeDefs(
+  originNodeId: string,
+  originHandleId: string,
+  nodes: Node<NodeData>[],
+  edges: Edge[],
+  allNodeDefs: NodeDefinition[],
+  isFunctionCanvas: boolean,
+): NodeDefinition[] {
+  const originNode = nodes.find((n) => n.id === originNodeId);
+  if (!originNode) return [];
+
+  const originPorts = getPorts(originNode.data);
+  const originPort = originPorts.output.find((p) => p.id === originHandleId);
+  if (!originPort) return [];
+
+  const originPortType = originPort.type; // "control" | "tool"
+
+  return allNodeDefs.filter((def) => {
+    if (def.isUnremovable) return false;
+
+    if (def.isSingleton && nodes.some((n) => n.data.type === def.type)) return false;
+
+    // Triggers have no inputs — skip on function canvas and when looking for input ports
+    if (isFunctionCanvas && def.category === "Trigger") return false;
+
+    // Check candidate has a matching input port
+    const candidatePorts = getPorts({ type: def.type } as NodeData);
+    return candidatePorts.input.some((p) => p.type === originPortType);
+  });
+}
+
+export const isValidConnection = (
+  sourceId: string | null,
+  targetId: string | null,
+  sourceHandleId: string | null | undefined,
+  targetHandleId: string | null | undefined,
+  nodes: Node<NodeData>[],
+  edges: Edge[],
+): false | EdgeType => {
+  // All handles must be present
+  if (sourceHandleId == null || targetHandleId == null || sourceId == null || targetId == null) return false;
+
+  // Find source and target nodes
+  const srcNode = nodes.find((n) => n.id === sourceId);
+  const tgtNode = nodes.find((n) => n.id === targetId);
+  if (!srcNode || !tgtNode) return false;
+
+  // Source-side checks via canPortAcceptEdge (multiple-outgoing + mutual exclusion)
+  if (!canPortAcceptEdge(srcNode.data, sourceHandleId, edges)) return false;
+
+  // Get ports using centralized dispatcher
+  const sourcePorts = getPorts(srcNode.data);
+  const targetPorts = getPorts(tgtNode.data);
+
+  const sourcePort = sourcePorts.output.find((p) => p.id === sourceHandleId);
+  const targetPort = targetPorts.input.find((p) => p.id === targetHandleId);
+  if (!sourcePort || !targetPort) return false;
+
+  // Only allow connections between same port types
+  if (sourcePort.type !== targetPort.type) return false;
+
+  // Target-side mutual exclusion checks
+  const portType = sourcePort.type as EdgeType;
+
+  if (portType === "tool") {
+    // Connecting a tool input on the target — reject if target already has control connections
+    if (hasControlFlowEdge(tgtNode.id, tgtNode.data, edges)) return false;
+  }
+
+  if (portType === "control") {
+    // Connecting a control port — reject if target already has tool INPUT connections
+    if (hasToolInputEdge(tgtNode.id, tgtNode.data, edges)) return false;
+  }
+
+  return portType;
+};