@foresthubai/workflow-builder 0.3.0

package/src/utils/connectionRules.ts

@@ -0,0 +1,137 @@
+// 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;
+};

package/src/utils/functionOperations.ts

@@ -0,0 +1,179 @@
+import type { Expression } from "@foresthubai/workflow-core";
+import type { DataType } from "@foresthubai/workflow-core/parameter";
+import type { FunctionDeclaration } from "@foresthubai/workflow-core/function";
+import { generateId } from "@foresthubai/workflow-core/id";
+import { ensureUid, type ApiVariable } from "@foresthubai/workflow-core/variable";
+import { useEditorStore } from "../stores/editorStore";
+import {
+  getCanvasStore,
+  getOrCreateCanvasStore,
+  deleteCanvasStore,
+  syncFunctionArgVariables,
+  notifyCanvasRegistryChange,
+} from "../stores/canvasStore";
+import { uniqueName } from "./resourceHelpers";
+
+/**
+ * Functions are a project-scoped resource: the declaration ({@link FunctionDeclaration}
+ * — signature + bundled output assignments) lives in editorStore, the body lives in
+ * the matching canvas store (id === fn.id). These operations keep the two in sync.
+ * Like channel/memory/model operations they write straight to the store (no undo
+ * history). A declaration change (name/arguments/outputs) forward-reconciles call
+ * sites via the migration subscription; an output *expression* edit does not (call
+ * sites never see the callee's expressions), so it doesn't bump the version.
+ */
+
+const emptyExpression = (dataType: DataType): Expression => ({ expression: "", references: [], dataType });
+
+/** Re-derive the body's fnarg variables from the declaration's current arguments. */
+function syncBody(fn: FunctionDeclaration): void {
+  const store = getCanvasStore(fn.id);
+  if (store) syncFunctionArgVariables(store, fn.arguments);
+}
+
+/**
+ * Apply an update to one function. `bumpVersion` is true for signature changes
+ * (name/arguments/outputs declaration) so call sites detect staleness, and false for
+ * pure output-expression edits. Version-bumping changes re-sync the body's fnargs.
+ */
+function mutate(id: string, updater: (fn: FunctionDeclaration) => FunctionDeclaration, bumpVersion: boolean): void {
+  let next: FunctionDeclaration | undefined;
+  useEditorStore.getState().setFunctions((fns) => {
+    const fn = fns[id];
+    if (!fn) return fns;
+    const updated = updater(fn);
+    next = bumpVersion ? { ...updated, version: fn.version + 1 } : updated;
+    return { ...fns, [id]: next };
+  });
+  if (next && bumpVersion) syncBody(next);
+}
+
+/** Create a new (empty) function + its body canvas. Returns the new definition. */
+export function addFunction(): FunctionDeclaration {
+  const id = generateId();
+  const existing = Object.values(useEditorStore.getState().functions).map((f) => f.name);
+  const fn: FunctionDeclaration = {
+    id,
+    version: 1,
+    name: uniqueName("function", existing),
+    arguments: [],
+    outputs: [],
+  };
+  useEditorStore.getState().setFunctions((fns) => ({ ...fns, [id]: fn }));
+  // Create the body canvas (seeds an OnFunctionCall node) and watch it.
+  getOrCreateCanvasStore(id);
+  notifyCanvasRegistryChange();
+  return fn;
+}
+
+/** Delete a function: its declaration, its body canvas, and any selection of it. */
+export function deleteFunction(id: string): void {
+  useEditorStore.getState().setFunctions((fns) => {
+    const { [id]: _drop, ...rest } = fns;
+    return rest;
+  });
+  deleteCanvasStore(id);
+  const sel = useEditorStore.getState().selection;
+  if (sel.kind === "function" && sel.id === id) {
+    useEditorStore.getState().clearSelection();
+  }
+}
+
+/** Rename a function. Call-site migration detects this via the name comparison, so
+ *  it needs no version bump. */
+export function renameFunction(id: string, name: string): void {
+  mutate(id, (fn) => ({ ...fn, name }), false);
+}
+
+// ── Input arguments (declarations) ─────────────────────────────────────────────
+
+export function addArgument(id: string): void {
+  mutate(
+    id,
+    (fn) => ({
+      ...fn,
+      arguments: [...fn.arguments, ensureUid({ name: `input${fn.arguments.length + 1}`, dataType: "string" })],
+    }),
+    true,
+  );
+}
+
+export function updateArgument(id: string, index: number, patch: Partial<ApiVariable>): void {
+  mutate(
+    id,
+    (fn) => {
+      const existing = fn.arguments[index];
+      if (!existing) return fn;
+      const next = [...fn.arguments];
+      next[index] = { ...existing, ...patch };
+      return { ...fn, arguments: next };
+    },
+    true,
+  );
+}
+
+export function removeArgument(id: string, index: number): void {
+  mutate(id, (fn) => ({ ...fn, arguments: fn.arguments.filter((_, i) => i !== index) }), true);
+}
+
+// ── Outputs (declaration + assignment bundled) ─────────────────────────────────
+
+export function addOutput(id: string): void {
+  mutate(
+    id,
+    (fn) => {
+      const dataType: DataType = "string";
+      return {
+        ...fn,
+        outputs: [...fn.outputs, { uid: generateId(), name: `output${fn.outputs.length + 1}`, dataType, expression: emptyExpression(dataType) }],
+      };
+    },
+    true,
+  );
+}
+
+/** Update an output's declaration (name/dataType). A dataType change retags the
+ *  bundled expression's dataType but keeps the entered text. */
+export function updateOutput(id: string, index: number, patch: { name?: string; dataType?: DataType }): void {
+  mutate(
+    id,
+    (fn) => {
+      const existing = fn.outputs[index];
+      if (!existing) return fn;
+      const dataType = patch.dataType ?? existing.dataType;
+      const next = [...fn.outputs];
+      next[index] = {
+        ...existing,
+        ...patch,
+        dataType,
+        expression: patch.dataType ? { ...existing.expression, dataType } : existing.expression,
+      };
+      return { ...fn, outputs: next };
+    },
+    true,
+  );
+}
+
+export function removeOutput(id: string, index: number): void {
+  mutate(id, (fn) => ({ ...fn, outputs: fn.outputs.filter((_, i) => i !== index) }), true);
+}
+
+/** Set one output's return-value expression. Not a signature change → no version bump. */
+export function setOutputExpression(id: string, index: number, expression: Expression): void {
+  mutate(
+    id,
+    (fn) => {
+      const existing = fn.outputs[index];
+      if (!existing) return fn;
+      const next = [...fn.outputs];
+      next[index] = { ...existing, expression };
+      return { ...fn, outputs: next };
+    },
+    false,
+  );
+}
+
+/** Read a function declaration without subscribing (for non-component callers). */
+export function getFunction(id: string): FunctionDeclaration | undefined {
+  return useEditorStore.getState().functions[id];
+}