syv-conductor-nodes 0.1.0__tar.gz

syv_conductor_nodes-0.1.0/.gitignore

@@ -0,0 +1,49 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg-info/
+*.egg
+dist/
+build/
+*.whl
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# uv
+uv.lock
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.mypy_cache/
+
+# Docs build
+site/
+
+# Notebooks
+*.ipynb
+.ipynb_checkpoints/
+# ...but keep the tutorial notebooks in examples/
+!examples/*.ipynb
+
+# Misc
+*.log
+.env
+.env.*

syv_conductor_nodes-0.1.0/LICENSE

@@ -0,0 +1,199 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Support. While redistributing the Work or
+      Derivative Works thereof, You may accept warranty, liability,
+      or other obligations and/or rights consistent with this License.
+      However, in accepting such obligations, You may act only on Your
+      own behalf and on Your sole responsibility, not on behalf of any
+      other Contributor, and only if You agree to indemnify, defend,
+      and hold each Contributor harmless for any liability incurred by,
+      or claims asserted against, such Contributor by reason of your
+      accepting any such warranty or support.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of a copyright owner be provided
+      on a separate line in the Source form of the Work.
+
+   Copyright 2026 Syvai
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied. See the License for the specific language governing
+   permissions and limitations under the License.

syv_conductor_nodes-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: syv-conductor-nodes
+Version: 0.1.0
+Summary: Standard-library nodes for conductor — text, math, logic, JSON, regex, and loop markers. Categories opt-in via register_all(registry, categories=[...]).
+Project-URL: Repository, https://github.com/syvai/conductor
+Author-email: Syvai <billy@syv.ai>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.0
+Requires-Dist: syv-conductor

syv_conductor_nodes-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "syv-conductor-nodes"
+version = "0.1.0"
+description = "Standard-library nodes for conductor — text, math, logic, JSON, regex, and loop markers. Categories opt-in via register_all(registry, categories=[...])."
+requires-python = ">=3.12"
+authors = [{ name = "Syvai", email = "billy@syv.ai" }]
+license = "Apache-2.0"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
+]
+dependencies = ["syv-conductor", "pydantic>=2.0"]
+
+[project.urls]
+Repository = "https://github.com/syvai/conductor"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/conductor_nodes"]

syv_conductor_nodes-0.1.0/src/conductor_nodes/__init__.py

@@ -0,0 +1,111 @@
+"""conductor-nodes — reusable node library for the conductor DAG engine.
+
+Each submodule exports a ``register(reg)`` function that attaches its nodes
+to a ``conductor.NodeRegistry``. Pick categories individually, or call
+``register_all()`` for everything.
+
+Example:
+
+    from conductor import NodeRegistry
+    from conductor_nodes import register_all
+
+    reg = NodeRegistry()
+    register_all(reg)
+
+    # …or just what you need:
+    from conductor_nodes import text, math
+    reg = NodeRegistry()
+    text.register(reg)
+    math.register(reg)
+
+Node IDs are prefixed by category (``text-uppercase``, ``math-add``, …) to
+minimize collisions with application-level node IDs. The canonical for-each
+markers — ``for-each-start`` and ``for-each-end`` — are kept unprefixed to
+match the conductor core's compound-region discovery.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from conductor_nodes import (
+    decision,
+    json_ops,
+    logic,
+    loop,
+    math,
+    regex_ops,
+    signal,
+    subprocess,
+    text,
+    while_loop,
+)
+
+if TYPE_CHECKING:
+    from conductor import NodeRegistry
+
+
+CATEGORIES: dict[str, object] = {
+    "text": text,
+    "math": math,
+    "logic": logic,
+    "loop": loop,
+    "json": json_ops,
+    "regex": regex_ops,
+    "decision": decision,
+    "while": while_loop,
+    "subprocess": subprocess,
+    "signal": signal,
+}
+
+
+def register_all(registry: "NodeRegistry", *, categories: list[str] | None = None) -> None:
+    """Register every (or a filtered subset of) category's nodes.
+
+    Args:
+        registry: The target ``NodeRegistry``.
+        categories: If provided, only these category names register. Unknown
+            names raise ``KeyError``. If None, every category registers.
+    """
+    names = list(CATEGORIES) if categories is None else categories
+    for name in names:
+        if name not in CATEGORIES:
+            raise KeyError(
+                f"Unknown category '{name}'. Known: {sorted(CATEGORIES)}"
+            )
+        CATEGORIES[name].register(registry)   # type: ignore[attr-defined]
+
+
+def get_default_registry(*, categories: list[str] | None = None) -> "NodeRegistry":
+    """Return a fresh ``NodeRegistry`` pre-populated with standard-library nodes.
+
+    Useful when you want to compose with your own registry via
+    ``my_reg.merge(get_default_registry())``. A new registry is built on
+    every call — no hidden shared state, mutating the result is safe.
+
+    Args:
+        categories: Optional subset of category names (same list as
+            ``register_all``). ``None`` means all categories.
+    """
+    from conductor import NodeRegistry
+
+    reg = NodeRegistry()
+    register_all(reg, categories=categories)
+    return reg
+
+
+__all__ = [
+    "CATEGORIES",
+    "register_all",
+    "get_default_registry",
+    "text",
+    "math",
+    "logic",
+    "loop",
+    "json_ops",
+    "regex_ops",
+    "decision",
+    "while_loop",
+    "subprocess",
+    "signal",
+]

syv_conductor_nodes-0.1.0/src/conductor_nodes/decision.py

@@ -0,0 +1,47 @@
+"""Built-in decision node.
+
+A decision node evaluates CEL ``when`` expressions on its outgoing edges
+and selectively marks branches as SKIPPED. Unlike an ``if-else`` node
+whose logic lives inside Python, the decision node makes branching
+visible on the diagram as data on the edges — the same pattern as BPMN
+gateways, Step Functions ``Choice``, and Temporal's continue-as.
+
+Register via :func:`register`; the runtime magic is in
+``conductor/execution/engine.py`` which detects ``is_decision=True`` nodes
+and post-processes their guards.
+
+The node's output is the ``value`` input passed through unchanged, so
+downstream consumers can still read the data that drove the decision.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated, Any
+
+from conductor.types import NodeCategory
+from conductor.widgets import Output, Text
+
+if TYPE_CHECKING:
+    from conductor import NodeRegistry
+
+
+def register(registry: "NodeRegistry") -> None:
+    """Register the canonical ``decision`` node."""
+
+    @registry.node(
+        "decision",
+        version=1,
+        name="Decision",
+        description=(
+            "Branching gateway. Evaluates `when` CEL expressions on outgoing "
+            "edges — exactly one branch is taken, the others are marked "
+            "SKIPPED."
+        ),
+        category=NodeCategory.DECISION,
+        is_decision=True,
+    )
+    def decision(
+        value: Annotated[Any, Text(label="Value")] = None,
+    ) -> Annotated[Any, Output(label="Pass-through")]:
+        """Pass the input through so downstream readers still see the value."""
+        return value

syv_conductor_nodes-0.1.0/src/conductor_nodes/json_ops.py

@@ -0,0 +1,61 @@
+"""JSON nodes (``json-parse``, ``json-stringify``, ``json-get``)."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Annotated, Any
+
+from conductor.widgets import Checkbox, Output, Range, Text, Textarea
+
+if TYPE_CHECKING:
+    from conductor import NodeRegistry
+
+
+def register(registry: "NodeRegistry") -> None:
+    """Register every JSON node on the supplied registry."""
+
+    @registry.node("json-parse", version=1, name="JSON Parse", description="Parses a JSON string into an object")
+    def parse(
+        text: Annotated[str, Textarea(label="JSON text")],
+    ) -> Annotated[object, Output(label="Parsed")]:
+        return json.loads(text)
+
+    @registry.node(
+        "json-stringify", version=1, name="JSON Stringify",
+        description="Serializes a value to a JSON string",
+    )
+    def stringify(
+        value: Annotated[object, Text(label="Value")],
+        indent: Annotated[int, Range(label="Indent", min_val=0, max_val=8, step=1)] = 0,
+        sort_keys: Annotated[bool, Checkbox(label="Sort keys")] = False,
+    ) -> Annotated[str, Output(label="JSON")]:
+        return json.dumps(value, indent=indent or None, sort_keys=sort_keys)
+
+    @registry.node(
+        "json-get", version=1, name="JSON Get",
+        description="Reads a dotted path from a JSON-like value (e.g. 'user.name', 'items.0.id')",
+    )
+    def get_path(
+        value: Annotated[object, Text(label="Value")],
+        path: Annotated[str, Text(label="Path")],
+    ) -> Annotated[object, Output(label="Extracted")]:
+        return _get_path(value, path)
+
+
+def _get_path(value: Any, path: str) -> Any:
+    """Walk a dotted path — each segment indexes a dict by key or a list by integer."""
+    if not path:
+        return value
+    current = value
+    for raw in path.split("."):
+        segment = raw.strip()
+        if isinstance(current, dict):
+            current = current.get(segment)
+        elif isinstance(current, list):
+            try:
+                current = current[int(segment)]
+            except (ValueError, IndexError):
+                return None
+        else:
+            return None
+    return current

syv_conductor_nodes-0.1.0/src/conductor_nodes/logic.py

@@ -0,0 +1,59 @@
+"""Control-flow / logic nodes that produce the SKIPPED sentinel to branch."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated
+
+from conductor._sentinel import SKIPPED
+from conductor.types import NodeCategory
+from conductor.widgets import Checkbox, Output, Text, Textarea
+
+if TYPE_CHECKING:
+    from conductor import NodeRegistry
+
+
+def register(registry: "NodeRegistry") -> None:
+    """Register every logic node on the supplied registry."""
+
+    @registry.node(
+        "logic-if-empty", version=1, name="If Empty",
+        description="Routes text based on whether it is empty (after strip)",
+        category=NodeCategory.CONTROL,
+    )
+    def if_empty(
+        text: Annotated[str, Textarea(label="Text")],
+    ) -> tuple[
+        Annotated[str, Output(label="Not empty")],
+        Annotated[str, Output(label="Empty")],
+    ]:
+        if text.strip():
+            return (text, SKIPPED)
+        return (SKIPPED, text)
+
+    @registry.node(
+        "logic-if-equals", version=1, name="If Equals",
+        description="Routes based on whether two strings are equal",
+        category=NodeCategory.CONTROL,
+    )
+    def if_equals(
+        a: Annotated[str, Text(label="A")],
+        b: Annotated[str, Text(label="B")],
+        case_sensitive: Annotated[bool, Checkbox(label="Case sensitive")] = True,
+    ) -> tuple[
+        Annotated[str, Output(label="Equal")],
+        Annotated[str, Output(label="Not equal")],
+    ]:
+        left = a if case_sensitive else a.lower()
+        right = b if case_sensitive else b.lower()
+        if left == right:
+            return (a, SKIPPED)
+        return (SKIPPED, a)
+
+    @registry.node(
+        "logic-not", version=1, name="Not",
+        description="Logical negation of a boolean",
+    )
+    def not_(
+        value: Annotated[bool, Checkbox(label="Value")],
+    ) -> Annotated[bool, Output(label="Negated")]:
+        return not value

syv_conductor_nodes-0.1.0/src/conductor_nodes/loop.py

@@ -0,0 +1,57 @@
+"""Canonical for-each loop markers.
+
+The engine's ``FOR_EACH`` compound node type discovers regions by looking
+for nodes whose registered ``base_id`` starts with ``for-each-start`` /
+``for-each-end``. These are the canonical implementations.
+
+To use the markers you must pass the ``FOR_EACH`` compound type to
+``compile()`` — nothing in this module wires that up for you:
+
+    from conductor import compile
+    from conductor.compound.for_each import FOR_EACH
+    from conductor_nodes import loop
+
+    loop.register(registry)
+    compiled = compile(nodes, edges, registry, compound_types=[FOR_EACH])
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated
+
+from conductor.types import NodeCategory
+from conductor.widgets import ConnectionList, Dropdown, Output, Text
+
+if TYPE_CHECKING:
+    from conductor import NodeRegistry
+
+
+def register(registry: "NodeRegistry") -> None:
+    """Register the for-each-start / for-each-end marker nodes."""
+
+    @registry.node(
+        "for-each-start", version=1, name="For Each (Start)",
+        description="Iterates over a list of items. Must be paired with for-each-end.",
+        category=NodeCategory.CONTROL,
+    )
+    def for_each_start(
+        items: Annotated[list, ConnectionList(label="Items")],
+        execution_mode: Annotated[
+            str,
+            Dropdown(label="Execution", choices=["Sequential", "Parallel"]),
+        ] = "Sequential",
+    ) -> tuple[
+        Annotated[object, Output(label="Item")],
+        Annotated[int, Output(label="Index")],
+    ]:
+        raise NotImplementedError("Handled by the FOR_EACH compound node")
+
+    @registry.node(
+        "for-each-end", version=1, name="For Each (End)",
+        description="Collects loop body results into a list",
+        category=NodeCategory.CONTROL,
+    )
+    def for_each_end(
+        item: Annotated[object, Text(label="Item")],
+    ) -> Annotated[list, Output(label="Collected")]:
+        raise NotImplementedError("Handled by the FOR_EACH compound node")

syv_conductor_nodes-0.1.0/src/conductor_nodes/math.py

@@ -0,0 +1,94 @@
+"""Arithmetic nodes (``math-add``, ``math-subtract``, etc.)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated
+
+from conductor.widgets import Output, Range, Text
+
+if TYPE_CHECKING:
+    from conductor import NodeRegistry
+
+
+def register(registry: "NodeRegistry") -> None:
+    """Register every math node on the supplied registry."""
+
+    @registry.node("math-add", version=1, name="Add", description="a + b")
+    def add(
+        a: Annotated[float, Text(label="A")],
+        b: Annotated[float, Text(label="B")],
+    ) -> Annotated[float, Output(label="Sum")]:
+        return a + b
+
+    @registry.node("math-subtract", version=1, name="Subtract", description="a - b")
+    def subtract(
+        a: Annotated[float, Text(label="A")],
+        b: Annotated[float, Text(label="B")],
+    ) -> Annotated[float, Output(label="Difference")]:
+        return a - b
+
+    @registry.node("math-multiply", version=1, name="Multiply", description="a * b")
+    def multiply(
+        a: Annotated[float, Text(label="A")],
+        b: Annotated[float, Text(label="B")],
+    ) -> Annotated[float, Output(label="Product")]:
+        return a * b
+
+    @registry.node(
+        "math-divide", version=1, name="Divide",
+        description="a / b — raises on b == 0",
+    )
+    def divide(
+        a: Annotated[float, Text(label="A")],
+        b: Annotated[float, Text(label="B")],
+    ) -> Annotated[float, Output(label="Quotient")]:
+        if b == 0:
+            raise ValueError("Division by zero")
+        return a / b
+
+    @registry.node("math-modulo", version=1, name="Modulo", description="a % b")
+    def modulo(
+        a: Annotated[float, Text(label="A")],
+        b: Annotated[float, Text(label="B")],
+    ) -> Annotated[float, Output(label="Remainder")]:
+        if b == 0:
+            raise ValueError("Modulo by zero")
+        return a % b
+
+    @registry.node(
+        "math-round", version=1, name="Round",
+        description="Rounds to the given number of decimals",
+    )
+    def round_(
+        value: Annotated[float, Text(label="Value")],
+        decimals: Annotated[int, Range(label="Decimals", min_val=0, max_val=10, step=1)] = 0,
+    ) -> Annotated[float, Output(label="Rounded")]:
+        return round(value, decimals)
+
+    @registry.node(
+        "math-min", version=1, name="Min",
+        description="Minimum of a list of numbers",
+    )
+    def min_(
+        values: Annotated[list[float], Text(label="Values")],
+    ) -> Annotated[float, Output(label="Min")]:
+        if not values:
+            raise ValueError("min requires at least one value")
+        return min(values)
+
+    @registry.node(
+        "math-max", version=1, name="Max",
+        description="Maximum of a list of numbers",
+    )
+    def max_(
+        values: Annotated[list[float], Text(label="Values")],
+    ) -> Annotated[float, Output(label="Max")]:
+        if not values:
+            raise ValueError("max requires at least one value")
+        return max(values)
+
+    @registry.node("math-abs", version=1, name="Absolute", description="|value|")
+    def abs_(
+        value: Annotated[float, Text(label="Value")],
+    ) -> Annotated[float, Output(label="Absolute")]:
+        return abs(value)

syv_conductor_nodes-0.1.0/src/conductor_nodes/regex_ops.py

@@ -0,0 +1,55 @@
+"""Regex nodes (``regex-match``, ``regex-replace``, ``regex-extract``)."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Annotated
+
+from conductor.widgets import Checkbox, Output, Text, Textarea
+
+if TYPE_CHECKING:
+    from conductor import NodeRegistry
+
+
+def register(registry: "NodeRegistry") -> None:
+    """Register every regex node on the supplied registry."""
+
+    @registry.node(
+        "regex-match", version=1, name="Regex Match",
+        description="True if the pattern matches anywhere in the text",
+    )
+    def match(
+        text: Annotated[str, Textarea(label="Text")],
+        pattern: Annotated[str, Text(label="Pattern")],
+        ignore_case: Annotated[bool, Checkbox(label="Ignore case")] = False,
+    ) -> Annotated[bool, Output(label="Matched")]:
+        flags = re.IGNORECASE if ignore_case else 0
+        return re.search(pattern, text, flags=flags) is not None
+
+    @registry.node(
+        "regex-replace", version=1, name="Regex Replace",
+        description="Replaces all pattern matches with `replacement`",
+    )
+    def replace(
+        text: Annotated[str, Textarea(label="Text")],
+        pattern: Annotated[str, Text(label="Pattern")],
+        replacement: Annotated[str, Text(label="Replace with")] = "",
+        ignore_case: Annotated[bool, Checkbox(label="Ignore case")] = False,
+    ) -> Annotated[str, Output(label="Result")]:
+        flags = re.IGNORECASE if ignore_case else 0
+        return re.sub(pattern, replacement, text, flags=flags)
+
+    @registry.node(
+        "regex-extract", version=1, name="Regex Extract",
+        description="Returns a list of all matches (or the first group of each, if present)",
+    )
+    def extract(
+        text: Annotated[str, Textarea(label="Text")],
+        pattern: Annotated[str, Text(label="Pattern")],
+        ignore_case: Annotated[bool, Checkbox(label="Ignore case")] = False,
+    ) -> Annotated[list[str], Output(label="Matches")]:
+        flags = re.IGNORECASE if ignore_case else 0
+        compiled = re.compile(pattern, flags=flags)
+        if compiled.groups:
+            return [m.group(1) for m in compiled.finditer(text)]
+        return compiled.findall(text)

syv_conductor_nodes-0.1.0/src/conductor_nodes/signal.py

@@ -0,0 +1,77 @@
+"""Signal / event nodes — pause until an external event arrives.
+
+Signal nodes are the general-purpose cousin of HITL: they pause the
+flow, checkpoint state, and hand off to the host. The host inspects the
+checkpoint's ``signal_name`` / ``correlation`` / timeout fields and
+wires those into its own message bus / webhook endpoint / timer daemon.
+When the signal fires, the host calls ``resume_sync(compiled,
+checkpoint, payload)`` to continue.
+
+Two kinds are registered:
+
+* ``signal-wait`` — waits for an explicit named event (``kind="event"``)
+  or a timer (``kind="timer"``). One node type, a ``kind`` discriminator.
+* ``signal-timer`` — convenience alias that only does time-based waits.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated, Any
+
+from conductor.errors import SignalRequired
+from conductor.types import NodeCategory
+from conductor.widgets import CodeEditor, Dropdown, Number, Output, Text
+
+if TYPE_CHECKING:
+    from conductor import NodeRegistry
+
+
+def register(registry: "NodeRegistry") -> None:
+    """Register the signal / timer / event nodes."""
+
+    @registry.node(
+        "signal-wait", version=1, name="Wait for Signal",
+        description=(
+            "Pauses the flow until an external signal arrives. The host "
+            "reads (signal_name, correlation, timeout_seconds) from the "
+            "checkpoint and resumes the flow when the signal fires."
+        ),
+        category=NodeCategory.EVENT,
+        is_signal=True,
+    )
+    def signal_wait(
+        kind: Annotated[
+            str,
+            Dropdown(label="Kind", choices=["event", "timer"]),
+        ] = "event",
+        signal_name: Annotated[str, Text(label="Signal name")] = "",
+        correlation: Annotated[
+            str, CodeEditor(label="Correlation (CEL)", description="Optional CEL expression")
+        ] = "",
+        timeout_seconds: Annotated[
+            float, Number(label="Timeout (seconds)")
+        ] = 0,
+    ) -> Annotated[Any, Output(label="Payload")]:
+        # If already resumed with a payload, surface it here. The engine
+        # injects the payload by pre-seeding results, so this function is
+        # only called on the initial pause.
+        raise SignalRequired(
+            signal_name or kind,
+            correlation=correlation or None,
+            timeout_seconds=timeout_seconds or None,
+        )
+
+    @registry.node(
+        "signal-timer", version=1, name="Timer",
+        description="Wait for a duration, then continue. Host fires the timer.",
+        category=NodeCategory.EVENT,
+        is_signal=True,
+    )
+    def signal_timer(
+        seconds: Annotated[float, Number(label="Seconds")] = 60,
+    ) -> Annotated[Any, Output(label="Fired at")]:
+        raise SignalRequired(
+            "timer",
+            correlation=None,
+            timeout_seconds=float(seconds),
+        )

syv_conductor_nodes-0.1.0/src/conductor_nodes/subprocess.py

@@ -0,0 +1,47 @@
+"""Subprocess-call marker node.
+
+See :mod:`conductor.compound.subprocess` for the runtime. Bind a
+``SubprocessRegistry`` when compiling:
+
+    from conductor import compile
+    from conductor.compound.subprocess import SUBPROCESS, SubprocessRegistry
+    from conductor_nodes import subprocess
+
+    subprocess.register(registry)
+    sub_registry = SubprocessRegistry()
+    sub_registry.register(other_flow)
+    compiled = compile(
+        flow=caller_flow, registry=registry,
+        compound_types=[SUBPROCESS],
+        subprocess_registry=sub_registry,
+    )
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated, Any
+
+from conductor.types import NodeCategory
+from conductor.widgets import Number, Output, SchemaBuilder, Text
+
+if TYPE_CHECKING:
+    from conductor import NodeRegistry
+
+
+def register(registry: "NodeRegistry") -> None:
+    """Register the subprocess-call marker node."""
+
+    @registry.node(
+        "subprocess-call", version=1, name="Subprocess",
+        description=(
+            "Calls another flow by id and version. The sub-flow runs "
+            "synchronously; its results are returned as this node's output."
+        ),
+        category=NodeCategory.CONTROL,
+    )
+    def subprocess_call(
+        flow_id: Annotated[str, Text(label="Flow id")] = "",
+        flow_version: Annotated[int, Number(label="Flow version", integer_only=True)] = 1,
+        inputs: Annotated[dict, SchemaBuilder(label="Input mapping")] = None,  # type: ignore[assignment]
+    ) -> Annotated[Any, Output(label="Sub-flow results")]:
+        raise NotImplementedError("Handled by the SUBPROCESS compound node")

syv_conductor_nodes-0.1.0/src/conductor_nodes/text.py

@@ -0,0 +1,91 @@
+"""Text-manipulation nodes (``text-uppercase``, ``text-lowercase``, etc.)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated
+
+from conductor.widgets import Checkbox, Output, Text, Textarea
+from conductor.widgets import List as ListWidget
+
+if TYPE_CHECKING:
+    from conductor import NodeRegistry
+
+
+def register(registry: "NodeRegistry") -> None:
+    """Register every text node on the supplied registry."""
+
+    @registry.node("text-uppercase", version=1, name="Uppercase", description="Returns the text in uppercase")
+    def uppercase(
+        text: Annotated[str, Textarea(label="Text")],
+    ) -> Annotated[str, Output(label="Uppercased")]:
+        return text.upper()
+
+    @registry.node("text-lowercase", version=1, name="Lowercase", description="Returns the text in lowercase")
+    def lowercase(
+        text: Annotated[str, Textarea(label="Text")],
+    ) -> Annotated[str, Output(label="Lowercased")]:
+        return text.lower()
+
+    @registry.node("text-trim", version=1, name="Trim", description="Strips leading/trailing whitespace")
+    def trim(
+        text: Annotated[str, Textarea(label="Text")],
+    ) -> Annotated[str, Output(label="Trimmed")]:
+        return text.strip()
+
+    @registry.node("text-length", version=1, name="Length", description="Character count of the text")
+    def length(
+        text: Annotated[str, Textarea(label="Text")],
+    ) -> Annotated[int, Output(label="Length")]:
+        return len(text)
+
+    @registry.node("text-concat", version=1, name="Concat", description="Concatenates two strings with an optional separator")
+    def concat(
+        a: Annotated[str, Text(label="A")],
+        b: Annotated[str, Text(label="B")],
+        separator: Annotated[str, Text(label="Separator")] = "",
+    ) -> Annotated[str, Output(label="Result")]:
+        return f"{a}{separator}{b}"
+
+    @registry.node(
+        "text-replace", version=1, name="Replace",
+        description="Replaces every occurrence of a substring with another",
+    )
+    def replace(
+        text: Annotated[str, Textarea(label="Text")],
+        needle: Annotated[str, Text(label="Find")],
+        replacement: Annotated[str, Text(label="Replace with")] = "",
+    ) -> Annotated[str, Output(label="Result")]:
+        return text.replace(needle, replacement)
+
+    @registry.node("text-contains", version=1, name="Contains", description="True if `needle` appears in `text`")
+    def contains(
+        text: Annotated[str, Textarea(label="Text")],
+        needle: Annotated[str, Text(label="Needle")],
+        case_sensitive: Annotated[bool, Checkbox(label="Case sensitive")] = True,
+    ) -> Annotated[bool, Output(label="Contains")]:
+        if case_sensitive:
+            return needle in text
+        return needle.lower() in text.lower()
+
+    @registry.node("text-split", version=1, name="Split", description="Splits text on a separator into a list")
+    def split(
+        text: Annotated[str, Textarea(label="Text")],
+        separator: Annotated[str, Text(label="Separator")] = ",",
+    ) -> Annotated[list[str], Output(label="Parts")]:
+        return text.split(separator)
+
+    @registry.node(
+        "text-join", version=1, name="Join",
+        description="Joins a list of strings with a separator",
+    )
+    def join(
+        parts: Annotated[list[str], ListWidget(label="Parts", item_widget=Text(label="Part"))],
+        separator: Annotated[str, Text(label="Separator")] = ", ",
+    ) -> Annotated[str, Output(label="Joined")]:
+        return separator.join(str(p) for p in parts)
+
+    @registry.node("text-reverse", version=1, name="Reverse", description="Returns the text reversed")
+    def reverse(
+        text: Annotated[str, Textarea(label="Text")],
+    ) -> Annotated[str, Output(label="Reversed")]:
+        return text[::-1]

syv_conductor_nodes-0.1.0/src/conductor_nodes/while_loop.py

@@ -0,0 +1,56 @@
+"""While-loop markers — canonical node ids the ``WHILE`` compound discovers.
+
+See :mod:`conductor.compound.while_loop` for the runtime behavior. To
+actually run a while-loop you must pass the ``WHILE`` compound type to
+``compile()``:
+
+    from conductor import compile
+    from conductor.compound.while_loop import WHILE
+    from conductor_nodes import while_loop
+
+    while_loop.register(registry)
+    compiled = compile(nodes, edges, registry, compound_types=[WHILE])
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated
+
+from conductor.types import NodeCategory
+from conductor.widgets import Checkbox, CodeEditor, Number, Output, Text
+
+if TYPE_CHECKING:
+    from conductor import NodeRegistry
+
+
+def register(registry: "NodeRegistry") -> None:
+    """Register the while-start / while-end marker nodes."""
+
+    @registry.node(
+        "while-start", version=1, name="While (Start)",
+        description=(
+            "Loops while a CEL condition is true. The condition has access to "
+            "`iteration` (the current 1-based count) and `last` (the body's "
+            "most recent return value). Must be paired with while-end."
+        ),
+        category=NodeCategory.CONTROL,
+    )
+    def while_start(
+        condition: Annotated[str, CodeEditor(label="Condition (CEL)")] = "iteration < 5",
+        max_iterations: Annotated[int, Number(label="Max iterations", integer_only=True)] = 1000,
+        negate: Annotated[bool, Checkbox(label="Until (negate condition)")] = False,
+    ) -> tuple[
+        Annotated[int, Output(label="Iteration")],
+        Annotated[object, Output(label="Last")],
+    ]:
+        raise NotImplementedError("Handled by the WHILE compound node")
+
+    @registry.node(
+        "while-end", version=1, name="While (End)",
+        description="Captures the body's last return value as the loop's result.",
+        category=NodeCategory.CONTROL,
+    )
+    def while_end(
+        item: Annotated[object, Text(label="Item")],
+    ) -> Annotated[object, Output(label="Last value")]:
+        raise NotImplementedError("Handled by the WHILE compound node")