weni-cli 3.7.0__tar.gz → 3.7.1__tar.gz

{weni_cli-3.7.0 → weni_cli-3.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: weni-cli
-Version: 3.7.0
+Version: 3.7.1
 Summary: 
 Author: Paulo Bernardo
 Author-email: paulo.bernardo@weni.ai
@@ -20,7 +20,7 @@ Requires-Dist: rich (>=13.9.4,<14.0.0)
 Requires-Dist: rich-click (>=1.8.6,<2.0.0)
 Requires-Dist: waitress (>=3.0.2,<4.0.0)
 Requires-Dist: weni-agenteval (>=1.1.0,<2.0.0)
-Requires-Dist: weni-agents-toolkit (==2.6.3)
+Requires-Dist: weni-agents-toolkit (==2.6.4)
 Description-Content-Type: text/markdown
 
 # Weni-CLI

{weni_cli-3.7.0 → weni_cli-3.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "weni-cli"
-version = "3.7.0"
+version = "3.7.1"
 description = ""
 authors = ["Paulo Bernardo <paulo.bernardo@weni.ai>", "Matheus Leal <matheus.cardoso@vtex.com>"]
 readme = "README.md"
@@ -14,7 +14,7 @@ waitress = "^3.0.2"
 pyyaml = "^6.0.2"
 python-slugify = "^8.0.4"
 regex = "^2024.11.6"
-weni-agents-toolkit = "2.6.3"
+weni-agents-toolkit = "2.6.4"
 rich-click = "^1.8.6"
 rich = "^13.9.4"
 weni-agenteval = "^1.1.0"

{weni_cli-3.7.0 → weni_cli-3.7.1}/weni_cli/commands/run.py

@@ -18,7 +18,9 @@ from weni_cli.validators.agent_definition import (
     format_definition,
     load_agent_definition,
     load_test_definition,
+    validate_active_agent_definition_schema,
     validate_active_test_definition,
+    validate_agent_definition_schema,
 )
 
 DEFAULT_TEST_DEFINITION_FILE = "test_definition.yaml"
@@ -94,6 +96,18 @@ class RunHandler(Handler):
 
         agent_type = detect_agent_type(definition_data)
 
+        schema_validator = (
+            validate_active_agent_definition_schema
+            if agent_type == ACTIVE_TYPE
+            else validate_agent_definition_schema
+        )
+        if validation_error := schema_validator(definition_data):
+            formatter.print_error_panel(
+                f"Invalid agent definition YAML file format, error:\n{validation_error}",
+                title="Failed to load definition file",
+            )
+            return
+
         if agent_type == ACTIVE_TYPE:
             self._execute_active(
                 definition_data=definition_data,

{weni_cli-3.7.0 → weni_cli-3.7.1}/weni_cli/validators/agent_definition.py

@@ -5,6 +5,8 @@ import yaml
 
 from slugify import slugify
 
+from weni_cli.validators.source import validate_entrypoint
+
 MIN_INSTRUCTION_LENGTH = 40
 MIN_GUARDRAIL_LENGTH = 40
 MAX_AGENT_NAME_LENGTH = 55
@@ -174,6 +176,13 @@ def validate_agent_definition_schema(data):
             if not isinstance(tool_data["source"]["entrypoint"], str):
                 return f"Agent '{agent_key}': tool '{tool_name}': 'source.entrypoint' must be a string in the agent definition file"
 
+            if error := validate_entrypoint(
+                context=f"Agent '{agent_key}': tool '{tool_name}'",
+                source_path=tool_data["source"]["path"],
+                entrypoint=tool_data["source"]["entrypoint"],
+            ):
+                return error
+
             # Validate source path_test if present (must be string)
             if "path_test" in tool_data["source"] and not isinstance(tool_data["source"]["path_test"], str):
                 return f"Agent '{agent_key}': tool '{tool_name}': 'source.path_test' must be a string in the agent definition file"
@@ -419,6 +428,13 @@ def validate_active_agent_definition_schema(data):
                 if not isinstance(rule_data["source"]["entrypoint"], str):
                     return f"Agent '{agent_key}': rule '{rule_key}': 'source.entrypoint' must be a string in the agent definition file"
 
+                if error := validate_entrypoint(
+                    context=f"Agent '{agent_key}': rule '{rule_key}'",
+                    source_path=rule_data["source"]["path"],
+                    entrypoint=rule_data["source"]["entrypoint"],
+                ):
+                    return error
+
                 # Validate start_condition (required, must be a string)
                 if not rule_data.get("start_condition"):
                     return f"Agent '{agent_key}': rule '{rule_key}' is missing required field 'start_condition' in the agent definition file"
@@ -461,6 +477,13 @@ def validate_active_agent_definition_schema(data):
             if not isinstance(agent_data["pre_processing"]["source"]["entrypoint"], str):
                 return f"Agent '{agent_key}': 'pre_processing.source.entrypoint' must be a string in the agent definition file"
 
+            if error := validate_entrypoint(
+                context=f"Agent '{agent_key}': pre_processing",
+                source_path=agent_data["pre_processing"]["source"]["path"],
+                entrypoint=agent_data["pre_processing"]["source"]["entrypoint"],
+            ):
+                return error
+
             # Validate result_examples_file (required, must be a string with a .json in suffix)
             if "result_examples_file" not in agent_data["pre_processing"]:
                 return f"Agent '{agent_key}': 'pre_processing' is missing required field 'result_examples_file' in the agent definition file"

weni_cli-3.7.1/weni_cli/validators/source.py

@@ -0,0 +1,134 @@
+"""Filesystem and AST-based validation for ``source.entrypoint`` definitions.
+
+The schema validator in :mod:`weni_cli.validators.agent_definition` only checks
+type and shape of YAML fields. This module complements it by verifying that
+the ``source.path`` actually exists on disk, that the referenced module file
+is present, and that the class named in ``entrypoint`` is declared in that
+module — all without importing or executing any user code.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+from typing import Optional
+
+
+ENTRYPOINT_FORMAT = "module.ClassName"
+
+
+def _is_valid_python_identifier(name: str) -> bool:
+    return name.isidentifier()
+
+
+def _parse_entrypoint(entrypoint: str) -> Optional[tuple[str, str]]:
+    """Return ``(module, class_name)`` if entrypoint matches ``module.ClassName``.
+
+    Rules:
+    - Exactly one dot separating two non-empty parts.
+    - Both parts must be valid Python identifiers (no digits leading, no spaces).
+    """
+    if not isinstance(entrypoint, str):
+        return None
+
+    parts = entrypoint.split(".")
+    if len(parts) != 2:
+        return None
+
+    module, class_name = parts
+    if not module or not class_name:
+        return None
+
+    if not _is_valid_python_identifier(module):
+        return None
+
+    if not _is_valid_python_identifier(class_name):
+        return None
+
+    return module, class_name
+
+
+def _class_exists_in_module(module_file: str, class_name: str) -> tuple[bool, Optional[str]]:
+    """Parse ``module_file`` with AST and check whether ``class_name`` is declared.
+
+    Returns ``(found, syntax_error)``. ``syntax_error`` is set only when the
+    file cannot be parsed as Python.
+    """
+    try:
+        with open(module_file, "r", encoding="utf-8") as handle:
+            source_code = handle.read()
+    except OSError as error:
+        return False, str(error)
+
+    try:
+        tree = ast.parse(source_code, filename=module_file)
+    except SyntaxError as error:
+        return False, f"{error.msg} (line {error.lineno})"
+
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef) and node.name == class_name:
+            return True, None
+
+    return False, None
+
+
+def validate_entrypoint(
+    context: str,
+    source_path: str,
+    entrypoint: str,
+    base_dir: Optional[str] = None,
+) -> Optional[str]:
+    """Validate ``entrypoint`` against the local filesystem.
+
+    Args:
+        context: Human-readable prefix for the error message (e.g.
+            ``"Agent 'cep_agent': tool 'get_address'"``).
+        source_path: Path to the resource folder, as written in the YAML.
+        entrypoint: ``module.ClassName`` string from ``source.entrypoint``.
+        base_dir: Directory to resolve relative paths against. Defaults to the
+            current working directory, matching how the packager resolves paths.
+
+    Returns:
+        ``None`` if everything checks out, otherwise a user-facing error
+        message describing the first problem encountered.
+    """
+    parsed = _parse_entrypoint(entrypoint)
+    if parsed is None:
+        return (
+            f"{context}: entrypoint '{entrypoint}' must follow the format "
+            f"'{ENTRYPOINT_FORMAT}'"
+        )
+
+    module, class_name = parsed
+
+    resolved_root = base_dir if base_dir is not None else os.getcwd()
+    resolved_source_path = (
+        source_path
+        if os.path.isabs(source_path)
+        else os.path.join(resolved_root, source_path)
+    )
+
+    if not os.path.isdir(resolved_source_path):
+        return f"{context}: source path '{source_path}' does not exist"
+
+    module_file = os.path.join(resolved_source_path, f"{module}.py")
+    if not os.path.isfile(module_file):
+        return (
+            f"{context}: module file '{source_path}{os.sep}{module}.py' not found "
+            f"for entrypoint '{entrypoint}'"
+        )
+
+    found, syntax_error = _class_exists_in_module(module_file, class_name)
+    if syntax_error is not None:
+        return (
+            f"{context}: failed to parse '{source_path}{os.sep}{module}.py' for "
+            f"entrypoint '{entrypoint}': {syntax_error}"
+        )
+
+    if not found:
+        return (
+            f"{context}: class '{class_name}' not found in "
+            f"'{source_path}{os.sep}{module}.py' for entrypoint '{entrypoint}'"
+        )
+
+    return None

weni_cli-3.7.1/weni_cli/validators/tests/conftest.py

@@ -0,0 +1,19 @@
+"""Shared fixtures for validator tests.
+
+The schema tests in :mod:`test_definition` operate on synthetic agent
+definitions and don't ship with real source paths or module files on disk.
+The newly introduced :func:`validate_entrypoint` would otherwise reject every
+one of them. Auto-mock it to ``None`` here so schema-shape tests keep their
+focus. Tests that exercise the entrypoint validator itself should import it
+directly from :mod:`weni_cli.validators.source`, which is not patched.
+"""
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def _bypass_entrypoint_validation(mocker):
+    mocker.patch(
+        "weni_cli.validators.agent_definition.validate_entrypoint",
+        return_value=None,
+    )

weni_cli-3.7.1/weni_cli/validators/tests/test_source.py

@@ -0,0 +1,156 @@
+"""Tests for :mod:`weni_cli.validators.source`.
+
+The autouse fixture in this folder's ``conftest.py`` patches
+``weni_cli.validators.agent_definition.validate_entrypoint``. The function
+under test here is imported directly from ``weni_cli.validators.source``, so
+those tests bypass the schema-level patch and exercise the real validator.
+"""
+
+from __future__ import annotations
+
+import os
+
+import pytest
+from click.testing import CliRunner
+
+from weni_cli.validators.source import (
+    ENTRYPOINT_FORMAT,
+    validate_entrypoint,
+)
+
+
+CONTEXT = "Agent 'cep_agent': tool 'get_address'"
+
+
+def _write_module(path: str, body: str) -> None:
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w") as handle:
+        handle.write(body)
+
+
+@pytest.mark.parametrize(
+    "bad_entrypoint",
+    [
+        "main",
+        "main.Foo.Bar",
+        "123.Foo",
+        ".Foo",
+        "main.",
+        "main Foo.Bar",
+        "",
+    ],
+)
+def test_invalid_entrypoint_format_is_rejected(bad_entrypoint):
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        os.makedirs("tools/get_address", exist_ok=True)
+
+        error = validate_entrypoint(CONTEXT, "tools/get_address", bad_entrypoint)
+
+        assert error is not None
+        assert ENTRYPOINT_FORMAT in error
+        assert CONTEXT in error
+
+
+def test_missing_source_path_is_rejected():
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        error = validate_entrypoint(CONTEXT, "tools/get_address", "main.GetAddress")
+
+        assert error is not None
+        assert "source path 'tools/get_address' does not exist" in error
+        assert CONTEXT in error
+
+
+def test_missing_module_file_is_rejected():
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        os.makedirs("tools/get_address", exist_ok=True)
+
+        error = validate_entrypoint(CONTEXT, "tools/get_address", "main.GetAddress")
+
+        assert error is not None
+        assert "module file" in error
+        assert "main.py" in error
+        assert CONTEXT in error
+
+
+def test_missing_class_is_rejected():
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        _write_module("tools/get_address/main.py", "class SomethingElse:\n    pass\n")
+
+        error = validate_entrypoint(CONTEXT, "tools/get_address", "main.GetAddress")
+
+        assert error is not None
+        assert "class 'GetAddress' not found" in error
+        assert CONTEXT in error
+
+
+def test_syntax_error_in_module_is_reported():
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        _write_module("tools/get_address/main.py", "class :::: pass\n")
+
+        error = validate_entrypoint(CONTEXT, "tools/get_address", "main.GetAddress")
+
+        assert error is not None
+        assert "failed to parse" in error
+        assert CONTEXT in error
+
+
+def test_happy_path_returns_none():
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        _write_module(
+            "tools/get_address/main.py",
+            "class GetAddress:\n    def execute(self, context):\n        return 'ok'\n",
+        )
+
+        assert (
+            validate_entrypoint(CONTEXT, "tools/get_address", "main.GetAddress")
+            is None
+        )
+
+
+def test_class_nested_inside_function_is_not_detected():
+    """Only top-level ``class`` declarations count, mirroring how the backend
+    imports the module to grab the entrypoint."""
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        _write_module(
+            "tools/get_address/main.py",
+            "def factory():\n    class GetAddress:\n        pass\n    return GetAddress\n",
+        )
+
+        error = validate_entrypoint(CONTEXT, "tools/get_address", "main.GetAddress")
+
+        assert error is not None
+        assert "class 'GetAddress' not found" in error
+
+
+def test_absolute_source_path_is_supported(tmp_path):
+    module_dir = tmp_path / "tools" / "get_address"
+    module_dir.mkdir(parents=True)
+    (module_dir / "main.py").write_text("class GetAddress: pass\n")
+
+    assert (
+        validate_entrypoint(CONTEXT, str(module_dir), "main.GetAddress")
+        is None
+    )
+
+
+def test_base_dir_resolves_relative_paths(tmp_path):
+    module_dir = tmp_path / "tools" / "get_address"
+    module_dir.mkdir(parents=True)
+    (module_dir / "main.py").write_text("class GetAddress: pass\n")
+
+    assert (
+        validate_entrypoint(
+            CONTEXT,
+            "tools/get_address",
+            "main.GetAddress",
+            base_dir=str(tmp_path),
+        )
+        is None
+    )