@foresthubai/workflow-core 0.3.0 → 0.4.0

package/src/node/MqttNode.ts

@@ -1,127 +1,127 @@
-import { NodeBase } from "./Node";
-import type { Expression } from "../api";
-import { OutputBinding } from "../parameter";
-import { NodeCategory, NodeTag } from "./constants";
-import { NodeDefinition } from "./NodeDefinition";
-
-// MQTT Publish - publishes a single value to an MQTT topic
-export interface MqttPublishNode extends NodeBase {
-  type: "MqttPublish";
-  arguments: {
-    channelReference: string;
-    dataType: "int" | "float" | "bool" | "string";
-    value: Expression;
-    qos: "0" | "1" | "2";
-    retain: boolean;
-  };
-}
-
-// On MQTT Message - fires when a message is received on a subscribed topic
-export interface OnMqttMessageNode extends NodeBase {
-  type: "OnMqttMessage";
-  arguments: {
-    channelReference: string;
-    dataType: "int" | "float" | "bool" | "string";
-    output: OutputBinding;
-  };
-}
-
-export type MqttNodeType = "MqttPublish" | "OnMqttMessage";
-export type MqttNode = MqttPublishNode | OnMqttMessageNode;
-
-// Node Definitions
-
-export const MqttPublishNodeDefinition: NodeDefinition = {
-  type: "MqttPublish",
-  label: "MQTT Publish",
-  category: NodeCategory.Output,
-  tags: [NodeTag.Network],
-  description: "Publish a value to an MQTT topic",
-  parameters: [
-    {
-      id: "channelReference",
-      label: "Channel",
-      description: "MQTT channel to publish through",
-      type: "channelSelect",
-      channelType: ["MQTT"],
-    },
-    {
-      id: "dataType",
-      label: "Data Type",
-      description: "Data type of the value to publish",
-      type: "selection",
-      options: [
-        { value: "int", label: "Integer" },
-        { value: "float", label: "Float" },
-        { value: "bool", label: "Boolean" },
-        { value: "string", label: "String" },
-      ],
-      default: "string",
-    },
-    {
-      id: "value",
-      label: "Value",
-      description: "Value to publish",
-      type: "expression",
-      expressionType: (args) => (args as MqttPublishNode["arguments"]).dataType,
-      default: { expression: "", references: [], dataType: "string" },
-    },
-    {
-      id: "qos",
-      label: "QoS",
-      description: "Quality of Service level",
-      type: "selection",
-      options: [
-        { value: "0", label: "0 - At most once" },
-        { value: "1", label: "1 - At least once" },
-        { value: "2", label: "2 - Exactly once" },
-      ],
-      default: "0",
-    },
-    {
-      id: "retain",
-      label: "Retain",
-      description: "Whether the broker should retain the message",
-      type: "bool",
-      default: false,
-    },
-  ],
-};
-
-export const OnMqttMessageNodeDefinition: NodeDefinition = {
-  type: "OnMqttMessage",
-  label: "On MQTT Message",
-  category: NodeCategory.Trigger,
-  tags: [NodeTag.Network],
-  description: "Fires when a message is received on a subscribed MQTT topic",
-  outputs: [
-    {
-      id: "output",
-      label: "Message Value",
-      type: "static",
-      dataType: (args) => (args as OnMqttMessageNode["arguments"]).dataType,
-    },
-  ],
-  parameters: [
-    {
-      id: "channelReference",
-      label: "Channel",
-      description: "MQTT channel to subscribe through",
-      type: "channelSelect",
-      channelType: ["MQTT"],
-    },
-    {
-      id: "dataType",
-      label: "Data Type",
-      description: "Expected data type of the received message value",
-      type: "selection",
-      options: [
-        { value: "int", label: "Integer" },
-        { value: "float", label: "Float" },
-        { value: "bool", label: "Boolean" },
-        { value: "string", label: "String" },
-      ],
-      default: "string",
-    },
-  ],
-};
+import { NodeBase } from "./Node";
+import type { Expression } from "../api";
+import { OutputBinding } from "../parameter";
+import { NodeCategory, NodeTag } from "./constants";
+import { NodeDefinition } from "./NodeDefinition";
+
+// MQTT Publish - publishes a single value to an MQTT topic
+export interface MqttPublishNode extends NodeBase {
+  type: "MqttPublish";
+  arguments: {
+    channelReference: string;
+    dataType: "int" | "float" | "bool" | "string";
+    value: Expression;
+    qos: "0" | "1" | "2";
+    retain: boolean;
+  };
+}
+
+// On MQTT Message - fires when a message is received on a subscribed topic
+export interface OnMqttMessageNode extends NodeBase {
+  type: "OnMqttMessage";
+  arguments: {
+    channelReference: string;
+    dataType: "int" | "float" | "bool" | "string";
+    output: OutputBinding;
+  };
+}
+
+export type MqttNodeType = "MqttPublish" | "OnMqttMessage";
+export type MqttNode = MqttPublishNode | OnMqttMessageNode;
+
+// Node Definitions
+
+export const MqttPublishNodeDefinition: NodeDefinition = {
+  type: "MqttPublish",
+  label: "MQTT Publish",
+  category: NodeCategory.Output,
+  tags: [NodeTag.Network],
+  description: "Publish a value to an MQTT topic",
+  parameters: [
+    {
+      id: "channelReference",
+      label: "Channel",
+      description: "MQTT channel to publish through",
+      type: "channelSelect",
+      channelType: ["MQTT"],
+    },
+    {
+      id: "dataType",
+      label: "Data Type",
+      description: "Data type of the value to publish",
+      type: "selection",
+      options: [
+        { value: "int", label: "Integer" },
+        { value: "float", label: "Float" },
+        { value: "bool", label: "Boolean" },
+        { value: "string", label: "String" },
+      ],
+      default: "string",
+    },
+    {
+      id: "value",
+      label: "Value",
+      description: "Value to publish",
+      type: "expression",
+      expressionType: (args) => (args as MqttPublishNode["arguments"]).dataType,
+      default: { expression: "", references: [], dataType: "string" },
+    },
+    {
+      id: "qos",
+      label: "QoS",
+      description: "Quality of Service level",
+      type: "selection",
+      options: [
+        { value: "0", label: "0 - At most once" },
+        { value: "1", label: "1 - At least once" },
+        { value: "2", label: "2 - Exactly once" },
+      ],
+      default: "0",
+    },
+    {
+      id: "retain",
+      label: "Retain",
+      description: "Whether the broker should retain the message",
+      type: "bool",
+      default: false,
+    },
+  ],
+};
+
+export const OnMqttMessageNodeDefinition: NodeDefinition = {
+  type: "OnMqttMessage",
+  label: "On MQTT Message",
+  category: NodeCategory.Trigger,
+  tags: [NodeTag.Network],
+  description: "Fires when a message is received on a subscribed MQTT topic",
+  outputs: [
+    {
+      id: "output",
+      label: "Message Value",
+      type: "static",
+      dataType: (args) => (args as OnMqttMessageNode["arguments"]).dataType,
+    },
+  ],
+  parameters: [
+    {
+      id: "channelReference",
+      label: "Channel",
+      description: "MQTT channel to subscribe through",
+      type: "channelSelect",
+      channelType: ["MQTT"],
+    },
+    {
+      id: "dataType",
+      label: "Data Type",
+      description: "Expected data type of the received message value",
+      type: "selection",
+      options: [
+        { value: "int", label: "Integer" },
+        { value: "float", label: "Float" },
+        { value: "bool", label: "Boolean" },
+        { value: "string", label: "String" },
+      ],
+      default: "string",
+    },
+  ],
+};

package/src/node/Node.ts

@@ -1,61 +1,61 @@
-// Domain Node — the base shape every node variant builds on. NodeBase is the
-// generic, untyped-parameters shape used wherever a node is handled generically
-// (e.g. React Flow nodes); NodeData is the discriminated union over the
-// per-variant interfaces (InputNode, AgentNode, …) for strongly-typed work.
-// Mirrors how channel/memory/model keep their base shape in a same-named file and
-// leave index.ts as a pure barrel. The per-variant interfaces import NodeBase
-// from here directly, not via the barrel.
-
-import type { DataType } from "../api";
-import { InputNode, InputNodeType } from "./InputNode";
-import { OutputNode, OutputNodeType } from "./OutputNode";
-import { AgentNode, AgentNodeType } from "./AgentNode";
-import { LogicNode, LogicNodeType } from "./LogicNode";
-import { DataNode, DataNodeType } from "./DataNode";
-import { TriggerNode, TriggerNodeType } from "./TriggerNode";
-import { ToolNode, ToolNodeType } from "./ToolNode";
-import { FunctionCallNode, FunctionCallNodeType } from "./FunctionNode";
-import { MqttNode, MqttNodeType } from "./MqttNode";
-
-export type NodeOutput = { name: string; dataType: DataType };
-export type NodeType =
-  | InputNodeType
-  | OutputNodeType
-  | AgentNodeType
-  | LogicNodeType
-  | DataNodeType
-  | TriggerNodeType
-  | ToolNodeType
-  | FunctionCallNodeType
-  | MqttNodeType;
-
-/**
- * NodeData represents the runtime data for a node in the workflow builder.
- * It is a union type of all specific node types, each with their own typed parameters.
- * Use this type when you need strong typing for a specific node.
- */
-export type NodeData = InputNode | OutputNode | AgentNode | LogicNode | DataNode | TriggerNode | ToolNode | FunctionCallNode | MqttNode;
-
-/**
- * Full domain node entity held on a {@link Canvas}: the {@link NodeData}
- * payload plus its canvas layout position, flattened. id/type/arguments/label
- * come from NodeData; only `position` is added. The editor projects this into
- * a React Flow node (adding the display type) at its store boundary.
- */
-export type Node = NodeData & { position: { x: number; y: number } };
-
-/**
- * NodeBase is a generic interface for all node instances.
- * It uses an untyped parameters record to allow generic parameter handling (e.g., in React Flow nodes).
- * Narrow to NodeData for specific node operations that require typed parameters.
- *
- * Per-output bindings (emit/assign/discard) live as flat entries inside `arguments`,
- * keyed by the output id — same namespace as parameter values. List output entries
- * (e.g. AgentNode's `outputDeclarations`) bundle their binding alongside their variable
- * declaration as OutputDeclaration[].
- */
-export interface NodeBase extends Record<string, unknown> {
-  id: string; // Same as the React Flow node ID
-  type: NodeType; // Node discriminator
-  label?: string; // User-editable display label (falls back to nodeDefinition.label)
-}
+// Domain Node — the base shape every node variant builds on. NodeBase is the
+// generic, untyped-parameters shape used wherever a node is handled generically
+// (e.g. React Flow nodes); NodeData is the discriminated union over the
+// per-variant interfaces (InputNode, AgentNode, …) for strongly-typed work.
+// Mirrors how channel/memory/model keep their base shape in a same-named file and
+// leave index.ts as a pure barrel. The per-variant interfaces import NodeBase
+// from here directly, not via the barrel.
+
+import type { DataType } from "../api";
+import { InputNode, InputNodeType } from "./InputNode";
+import { OutputNode, OutputNodeType } from "./OutputNode";
+import { AgentNode, AgentNodeType } from "./AgentNode";
+import { LogicNode, LogicNodeType } from "./LogicNode";
+import { DataNode, DataNodeType } from "./DataNode";
+import { TriggerNode, TriggerNodeType } from "./TriggerNode";
+import { ToolNode, ToolNodeType } from "./ToolNode";
+import { FunctionCallNode, FunctionCallNodeType } from "./FunctionNode";
+import { MqttNode, MqttNodeType } from "./MqttNode";
+
+export type NodeOutput = { name: string; dataType: DataType };
+export type NodeType =
+  | InputNodeType
+  | OutputNodeType
+  | AgentNodeType
+  | LogicNodeType
+  | DataNodeType
+  | TriggerNodeType
+  | ToolNodeType
+  | FunctionCallNodeType
+  | MqttNodeType;
+
+/**
+ * NodeData represents the runtime data for a node in the workflow builder.
+ * It is a union type of all specific node types, each with their own typed parameters.
+ * Use this type when you need strong typing for a specific node.
+ */
+export type NodeData = InputNode | OutputNode | AgentNode | LogicNode | DataNode | TriggerNode | ToolNode | FunctionCallNode | MqttNode;
+
+/**
+ * Full domain node entity held on a {@link Canvas}: the {@link NodeData}
+ * payload plus its canvas layout position, flattened. id/type/arguments/label
+ * come from NodeData; only `position` is added. The editor projects this into
+ * a React Flow node (adding the display type) at its store boundary.
+ */
+export type Node = NodeData & { position: { x: number; y: number } };
+
+/**
+ * NodeBase is a generic interface for all node instances.
+ * It uses an untyped parameters record to allow generic parameter handling (e.g., in React Flow nodes).
+ * Narrow to NodeData for specific node operations that require typed parameters.
+ *
+ * Per-output bindings (emit/assign/discard) live as flat entries inside `arguments`,
+ * keyed by the output id — same namespace as parameter values. List output entries
+ * (e.g. AgentNode's `outputDeclarations`) bundle their binding alongside their variable
+ * declaration as OutputDeclaration[].
+ */
+export interface NodeBase extends Record<string, unknown> {
+  id: string; // Same as the React Flow node ID
+  type: NodeType; // Node discriminator
+  label?: string; // User-editable display label (falls back to nodeDefinition.label)
+}

package/src/node/NodeDefinition.ts

@@ -1,37 +1,37 @@
-import { NodeType } from "./Node";
-import { NodeCategory, NodeTag } from "./constants";
-import { OutputParameter, Parameter } from "../parameter";
-
-/**
- * NodeDefinition describes static class-level node metadata.
- * Methods (getPorts) are optional and take no arguments for static port definitions.
- * Instance-dependent behavior lives in NodeBehavior.ts instead.
- */
-export interface NodeDefinition {
-  type: NodeType; // Node discriminator
-  label: string; // Human-readable, displayed name
-  category: NodeCategory; // Category for grouping (e.g., 'Input', 'Output', 'Logic')
-  description: string; // Description of what the node does
-  parameters: Parameter[]; // Parameter definitions for the node.
-  outputs?: OutputParameter[]; // Declarative output definitions — consumed by getNodeAvailableOutput() to compute a node's outputs
-  tags?: NodeTag[]; // Cross-cutting subsystem labels (Network, Pin, Serial, ...)
-  isUnremovable?: boolean; // Whether the node cannot be added or removed by a user
-  isSingleton?: boolean; // Whether only one instance of this node can exist in a canvas
-  canBranch?: boolean; // Whether the control output port may fan out to multiple branches (tool output ports are always multi-target)
-}
-
-// =============================================================================
-// PORT DEFINITIONS
-// =============================================================================
-
-// Port represents a connectable port of a node
-export interface Port {
-  id: string;
-  type: "control" | "tool";
-  label?: string;
-}
-
-export interface PortDefinitions {
-  input: Port[];
-  output: Port[];
-}
+import { NodeType } from "./Node";
+import { NodeCategory, NodeTag } from "./constants";
+import { OutputParameter, Parameter } from "../parameter";
+
+/**
+ * NodeDefinition describes static class-level node metadata.
+ * Methods (getPorts) are optional and take no arguments for static port definitions.
+ * Instance-dependent behavior lives in NodeBehavior.ts instead.
+ */
+export interface NodeDefinition {
+  type: NodeType; // Node discriminator
+  label: string; // Human-readable, displayed name
+  category: NodeCategory; // Category for grouping (e.g., 'Input', 'Output', 'Logic')
+  description: string; // Description of what the node does
+  parameters: Parameter[]; // Parameter definitions for the node.
+  outputs?: OutputParameter[]; // Declarative output definitions — consumed by getNodeAvailableOutput() to compute a node's outputs
+  tags?: NodeTag[]; // Cross-cutting subsystem labels (Network, Pin, Serial, ...)
+  isUnremovable?: boolean; // Whether the node cannot be added or removed by a user
+  isSingleton?: boolean; // Whether only one instance of this node can exist in a canvas
+  canBranch?: boolean; // Whether the control output port may fan out to multiple branches (tool output ports are always multi-target)
+}
+
+// =============================================================================
+// PORT DEFINITIONS
+// =============================================================================
+
+// Port represents a connectable port of a node
+export interface Port {
+  id: string;
+  type: "control" | "tool";
+  label?: string;
+}
+
+export interface PortDefinitions {
+  input: Port[];
+  output: Port[];
+}

package/src/node/NodeRegistry.ts

@@ -1,85 +1,85 @@
-import { ReadPinNodeDefinition, SerialReadNodeDefinition, RetrieverNodeDefinition, WebFetchNodeDefinition } from "./InputNode";
-import { AgentNodeDefinition } from "./AgentNode";
-import {
-  DelayNodeDefinition,
-  TickerNodeDefinition,
-  AlarmNodeDefinition,
-  OnFunctionCallNodeDefinition,
-  OnStartupNodeDefinition,
-  OnPinEdgeNodeDefinition,
-  OnSerialReceiveNodeDefinition,
-  OnThresholdNodeDefinition,
-} from "./TriggerNode";
-import { WebSearchToolNodeDefinition } from "./ToolNode";
-import { NodeType } from "./Node";
-import { NodeCategory } from "./constants";
-import { SerialWriteNodeDefinition, WritePinNodeDefinition } from "./OutputNode";
-import { IfNodeDefinition } from "./LogicNode";
-import { SetVariableNodeDefinition } from "./DataNode";
-import { MqttPublishNodeDefinition, OnMqttMessageNodeDefinition } from "./MqttNode";
-import { NodeDefinition } from "./NodeDefinition";
-
-/**
- * Central registry for all node definitions.
- */
-class NodeDefinitionRegistry {
-  private nodes: Map<NodeType, NodeDefinition> = new Map();
-  private initialized = false;
-
-  initialize() {
-    if (this.initialized) return;
-
-    // Register all nodes
-    this.register(ReadPinNodeDefinition);
-    this.register(SerialReadNodeDefinition);
-    this.register(WritePinNodeDefinition);
-    this.register(SerialWriteNodeDefinition);
-    this.register(AgentNodeDefinition);
-    this.register(IfNodeDefinition);
-    this.register(SetVariableNodeDefinition);
-    // Register trigger nodes
-    this.register(OnFunctionCallNodeDefinition);
-    this.register(DelayNodeDefinition);
-    this.register(TickerNodeDefinition);
-    this.register(AlarmNodeDefinition);
-    this.register(OnStartupNodeDefinition);
-    this.register(OnPinEdgeNodeDefinition);
-    this.register(OnSerialReceiveNodeDefinition);
-    this.register(OnThresholdNodeDefinition);
-    // Register tool nodes
-    this.register(WebSearchToolNodeDefinition);
-    // Register input tool nodes
-    this.register(RetrieverNodeDefinition);
-    this.register(WebFetchNodeDefinition);
-    // Register MQTT nodes
-    this.register(MqttPublishNodeDefinition);
-    this.register(OnMqttMessageNodeDefinition);
-
-    this.initialized = true;
-  }
-
-  private register(definition: NodeDefinition) {
-    this.nodes.set(definition.type, definition);
-  }
-
-  getAll(): NodeDefinition[] {
-    return Array.from(this.nodes.values());
-  }
-
-  getAllCategories(): NodeCategory[] {
-    const categories = new Set(this.getAll().map((node) => node.category));
-    return Array.from(categories).sort();
-  }
-
-  getByType(type: NodeType): NodeDefinition | undefined {
-    return this.nodes.get(type);
-  }
-
-  getByCategory(category: NodeCategory): NodeDefinition[] {
-    return this.getAll().filter((node) => node.category === category);
-  }
-}
-
-// Create and initialize the registry
-export const NodeRegistry = new NodeDefinitionRegistry();
-NodeRegistry.initialize();
+import { ReadPinNodeDefinition, SerialReadNodeDefinition, RetrieverNodeDefinition, WebFetchNodeDefinition } from "./InputNode";
+import { AgentNodeDefinition } from "./AgentNode";
+import {
+  DelayNodeDefinition,
+  TickerNodeDefinition,
+  AlarmNodeDefinition,
+  OnFunctionCallNodeDefinition,
+  OnStartupNodeDefinition,
+  OnPinEdgeNodeDefinition,
+  OnSerialReceiveNodeDefinition,
+  OnThresholdNodeDefinition,
+} from "./TriggerNode";
+import { WebSearchToolNodeDefinition } from "./ToolNode";
+import { NodeType } from "./Node";
+import { NodeCategory } from "./constants";
+import { SerialWriteNodeDefinition, WritePinNodeDefinition } from "./OutputNode";
+import { IfNodeDefinition } from "./LogicNode";
+import { SetVariableNodeDefinition } from "./DataNode";
+import { MqttPublishNodeDefinition, OnMqttMessageNodeDefinition } from "./MqttNode";
+import { NodeDefinition } from "./NodeDefinition";
+
+/**
+ * Central registry for all node definitions.
+ */
+class NodeDefinitionRegistry {
+  private nodes: Map<NodeType, NodeDefinition> = new Map();
+  private initialized = false;
+
+  initialize() {
+    if (this.initialized) return;
+
+    // Register all nodes
+    this.register(ReadPinNodeDefinition);
+    this.register(SerialReadNodeDefinition);
+    this.register(WritePinNodeDefinition);
+    this.register(SerialWriteNodeDefinition);
+    this.register(AgentNodeDefinition);
+    this.register(IfNodeDefinition);
+    this.register(SetVariableNodeDefinition);
+    // Register trigger nodes
+    this.register(OnFunctionCallNodeDefinition);
+    this.register(DelayNodeDefinition);
+    this.register(TickerNodeDefinition);
+    this.register(AlarmNodeDefinition);
+    this.register(OnStartupNodeDefinition);
+    this.register(OnPinEdgeNodeDefinition);
+    this.register(OnSerialReceiveNodeDefinition);
+    this.register(OnThresholdNodeDefinition);
+    // Register tool nodes
+    this.register(WebSearchToolNodeDefinition);
+    // Register input tool nodes
+    this.register(RetrieverNodeDefinition);
+    this.register(WebFetchNodeDefinition);
+    // Register MQTT nodes
+    this.register(MqttPublishNodeDefinition);
+    this.register(OnMqttMessageNodeDefinition);
+
+    this.initialized = true;
+  }
+
+  private register(definition: NodeDefinition) {
+    this.nodes.set(definition.type, definition);
+  }
+
+  getAll(): NodeDefinition[] {
+    return Array.from(this.nodes.values());
+  }
+
+  getAllCategories(): NodeCategory[] {
+    const categories = new Set(this.getAll().map((node) => node.category));
+    return Array.from(categories).sort();
+  }
+
+  getByType(type: NodeType): NodeDefinition | undefined {
+    return this.nodes.get(type);
+  }
+
+  getByCategory(category: NodeCategory): NodeDefinition[] {
+    return this.getAll().filter((node) => node.category === category);
+  }
+}
+
+// Create and initialize the registry
+export const NodeRegistry = new NodeDefinitionRegistry();
+NodeRegistry.initialize();