yamlgraph 0.3.9__py3-none-any.whl

tests/unit/test_prompts.py

@@ -0,0 +1,324 @@
+"""Tests for yamlgraph.utils.prompts module.
+
+TDD: Red phase - write tests before implementation.
+"""
+
+from pathlib import Path
+
+import pytest
+
+
+class TestResolvePromptPath:
+    """Tests for resolve_prompt_path function."""
+
+    def test_resolve_standard_prompt(self, tmp_path: Path):
+        """Should resolve prompt in standard prompts/ directory."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # Create temp prompt file
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+        prompt_file = prompts_dir / "greet.yaml"
+        prompt_file.write_text("system: Hello\nuser: Hi {name}")
+
+        result = resolve_prompt_path("greet", prompts_dir=prompts_dir)
+
+        assert result == prompt_file
+        assert result.exists()
+
+    def test_resolve_nested_prompt(self, tmp_path: Path):
+        """Should resolve nested prompt like map-demo/generate_ideas."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # Create nested prompt structure
+        prompts_dir = tmp_path / "prompts"
+        nested_dir = prompts_dir / "map-demo"
+        nested_dir.mkdir(parents=True)
+        prompt_file = nested_dir / "generate_ideas.yaml"
+        prompt_file.write_text("system: Generate\nuser: {topic}")
+
+        result = resolve_prompt_path("map-demo/generate_ideas", prompts_dir=prompts_dir)
+
+        assert result == prompt_file
+
+    def test_resolve_external_example_prompt(self, tmp_path: Path, monkeypatch):
+        """Should resolve external example like examples/storyboard/expand_story."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # Create external example structure: {parent}/prompts/{basename}.yaml
+        example_dir = tmp_path / "examples" / "storyboard"
+        prompts_subdir = example_dir / "prompts"
+        prompts_subdir.mkdir(parents=True)
+        prompt_file = prompts_subdir / "expand_story.yaml"
+        prompt_file.write_text("system: Expand\nuser: {story}")
+
+        # Change to tmp_path so relative paths resolve correctly
+        monkeypatch.chdir(tmp_path)
+
+        # Standard prompts dir doesn't have it, should fall back to external
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir(exist_ok=True)
+
+        result = resolve_prompt_path(
+            "examples/storyboard/expand_story",
+            prompts_dir=prompts_dir,
+        )
+
+        assert result.resolve() == prompt_file.resolve()
+
+    def test_resolve_nonexistent_raises(self, tmp_path: Path):
+        """Should raise FileNotFoundError for missing prompt."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+
+        with pytest.raises(FileNotFoundError, match="Prompt not found"):
+            resolve_prompt_path("nonexistent", prompts_dir=prompts_dir)
+
+    def test_resolve_uses_default_prompts_dir(self):
+        """Should use PROMPTS_DIR from config when not specified."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # This should find the real greet.yaml in prompts/
+        result = resolve_prompt_path("greet")
+
+        assert result.exists()
+        assert result.name == "greet.yaml"
+
+
+class TestLoadPrompt:
+    """Tests for load_prompt function."""
+
+    def test_load_existing_prompt(self, tmp_path: Path):
+        """Should load and parse YAML prompt file."""
+        from yamlgraph.utils.prompts import load_prompt
+
+        # Create temp prompt file
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+        prompt_file = prompts_dir / "test.yaml"
+        prompt_file.write_text("system: You are helpful\nuser: Hello {name}")
+
+        result = load_prompt("test", prompts_dir=prompts_dir)
+
+        assert result["system"] == "You are helpful"
+        assert result["user"] == "Hello {name}"
+
+    def test_load_prompt_with_schema(self, tmp_path: Path):
+        """Should load prompt with inline schema section."""
+        from yamlgraph.utils.prompts import load_prompt
+
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+        prompt_file = prompts_dir / "structured.yaml"
+        prompt_file.write_text("""
+system: Analyze content
+user: "{content}"
+schema:
+  name: Analysis
+  fields:
+    summary:
+      type: str
+      description: Brief summary
+""")
+
+        result = load_prompt("structured", prompts_dir=prompts_dir)
+
+        assert "schema" in result
+        assert result["schema"]["name"] == "Analysis"
+
+    def test_load_nonexistent_raises(self, tmp_path: Path):
+        """Should raise FileNotFoundError for missing prompt."""
+        from yamlgraph.utils.prompts import load_prompt
+
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+
+        with pytest.raises(FileNotFoundError):
+            load_prompt("missing", prompts_dir=prompts_dir)
+
+    def test_load_real_generate_prompt(self):
+        """Should load the real generate.yaml from prompts/."""
+        from yamlgraph.utils.prompts import load_prompt
+
+        result = load_prompt("generate")
+
+        assert "system" in result
+        assert "user" in result
+
+
+class TestGraphRelativePrompts:
+    """Tests for graph-relative prompt resolution (FR-A)."""
+
+    def test_resolve_prompt_relative_to_graph(self, tmp_path: Path):
+        """Should resolve prompt relative to graph file location."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # Create graph structure with colocated prompts
+        # questionnaires/audit/graph.yaml
+        # questionnaires/audit/prompts/opening.yaml
+        graph_dir = tmp_path / "questionnaires" / "audit"
+        prompts_dir = graph_dir / "prompts"
+        prompts_dir.mkdir(parents=True)
+
+        graph_file = graph_dir / "graph.yaml"
+        graph_file.write_text("name: audit")
+
+        prompt_file = prompts_dir / "opening.yaml"
+        prompt_file.write_text("system: Welcome\nuser: Start audit")
+
+        # Resolve relative to graph
+        result = resolve_prompt_path(
+            "prompts/opening",
+            graph_path=graph_file,
+            prompts_relative=True,
+        )
+
+        assert result == prompt_file
+        assert result.exists()
+
+    def test_resolve_prompt_explicit_prompts_dir(self, tmp_path: Path):
+        """Should use explicit prompts_dir when specified."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # Create shared prompts directory
+        shared_prompts = tmp_path / "shared" / "prompts"
+        shared_prompts.mkdir(parents=True)
+
+        prompt_file = shared_prompts / "greet.yaml"
+        prompt_file.write_text("system: Hello\nuser: Hi")
+
+        result = resolve_prompt_path(
+            "greet",
+            prompts_dir=shared_prompts,
+        )
+
+        assert result == prompt_file
+
+    def test_prompts_dir_overrides_relative(self, tmp_path: Path):
+        """Explicit prompts_dir should override prompts_relative."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # Create both graph-relative and explicit prompts
+        graph_dir = tmp_path / "graphs"
+        graph_dir.mkdir()
+        graph_file = graph_dir / "test.yaml"
+        graph_file.write_text("name: test")
+
+        # Graph-relative prompt (should NOT be used)
+        graph_prompts = graph_dir / "prompts"
+        graph_prompts.mkdir()
+        (graph_prompts / "greet.yaml").write_text("system: Graph local")
+
+        # Explicit prompts dir (should be used)
+        explicit_dir = tmp_path / "explicit"
+        explicit_dir.mkdir()
+        explicit_prompt = explicit_dir / "greet.yaml"
+        explicit_prompt.write_text("system: Explicit")
+
+        result = resolve_prompt_path(
+            "greet",
+            prompts_dir=explicit_dir,  # Explicit takes precedence
+            graph_path=graph_file,
+            prompts_relative=True,
+        )
+
+        assert result == explicit_prompt
+
+    def test_relative_resolution_without_graph_path_raises(self, tmp_path: Path):
+        """Should raise if prompts_relative=True but no graph_path."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+        (prompts_dir / "greet.yaml").write_text("system: Hi")
+
+        with pytest.raises(ValueError, match="graph_path required"):
+            resolve_prompt_path(
+                "greet",
+                prompts_relative=True,
+                # graph_path not provided
+            )
+
+    def test_relative_resolution_nested_prompt(self, tmp_path: Path):
+        """Should resolve nested prompts relative to graph."""
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # questionnaires/phq9/graph.yaml
+        # questionnaires/phq9/prompts/extract/fields.yaml
+        graph_dir = tmp_path / "questionnaires" / "phq9"
+        prompts_dir = graph_dir / "prompts" / "extract"
+        prompts_dir.mkdir(parents=True)
+
+        graph_file = graph_dir / "graph.yaml"
+        graph_file.write_text("name: phq9")
+
+        prompt_file = prompts_dir / "fields.yaml"
+        prompt_file.write_text("system: Extract\nuser: {text}")
+
+        result = resolve_prompt_path(
+            "prompts/extract/fields",
+            graph_path=graph_file,
+            prompts_relative=True,
+        )
+
+        assert result == prompt_file
+
+    def test_prompts_relative_with_prompts_dir_combines_paths(self, tmp_path: Path):
+        """When BOTH prompts_relative and prompts_dir are set, combine them.
+
+        Bug: prompts_dir should be resolved RELATIVE to graph_path.parent
+        when prompts_relative=True, not as an absolute/CWD-relative path.
+
+        Structure:
+            questionnaires/audit/
+                graph.yaml (with prompts_relative: true, prompts_dir: prompts)
+                prompts/
+                    opening.yaml
+
+        Expected: "opening" resolves to questionnaires/audit/prompts/opening.yaml
+        """
+        from yamlgraph.utils.prompts import resolve_prompt_path
+
+        # Create the structure
+        graph_dir = tmp_path / "questionnaires" / "audit"
+        prompts_dir = graph_dir / "prompts"
+        prompts_dir.mkdir(parents=True)
+
+        graph_file = graph_dir / "graph.yaml"
+        graph_file.write_text("name: audit")
+
+        prompt_file = prompts_dir / "opening.yaml"
+        prompt_file.write_text("system: Welcome\nuser: Start audit")
+
+        # This should resolve to questionnaires/audit/prompts/opening.yaml
+        # Note: prompts_dir is a RELATIVE path "prompts", not an absolute path
+        result = resolve_prompt_path(
+            "opening",
+            prompts_dir="prompts",  # Relative path!
+            graph_path=graph_file,
+            prompts_relative=True,
+        )
+
+        # Should resolve to the prompt colocated with the graph
+        assert result == prompt_file
+        assert result.exists()
+
+
+class TestLoadPromptPath:
+    """Tests for load_prompt_path (returns Path + parsed content)."""
+
+    def test_load_prompt_path_returns_both(self, tmp_path: Path):
+        """Should return both path and parsed content."""
+        from yamlgraph.utils.prompts import load_prompt_path
+
+        prompts_dir = tmp_path / "prompts"
+        prompts_dir.mkdir()
+        prompt_file = prompts_dir / "dual.yaml"
+        prompt_file.write_text("system: Test\nuser: Hello")
+
+        path, content = load_prompt_path("dual", prompts_dir=prompts_dir)
+
+        assert path == prompt_file
+        assert content["system"] == "Test"

tests/unit/test_python_nodes.py

@@ -0,0 +1,198 @@
+"""Tests for Python tool nodes (type: python)."""
+
+import pytest
+
+from yamlgraph.tools.python_tool import (
+    PythonToolConfig,
+    create_python_node,
+    load_python_function,
+    parse_python_tools,
+)
+
+
+class TestPythonToolConfig:
+    """Tests for PythonToolConfig dataclass."""
+
+    def test_basic_config(self):
+        """Can create config with required fields."""
+        config = PythonToolConfig(
+            module="os.path",
+            function="join",
+        )
+        assert config.module == "os.path"
+        assert config.function == "join"
+        assert config.description == ""
+
+    def test_config_with_description(self):
+        """Can create config with description."""
+        config = PythonToolConfig(
+            module="json",
+            function="dumps",
+            description="Serialize to JSON",
+        )
+        assert config.description == "Serialize to JSON"
+
+
+class TestLoadPythonFunction:
+    """Tests for load_python_function."""
+
+    def test_loads_stdlib_function(self):
+        """Can load function from stdlib."""
+        config = PythonToolConfig(module="os.path", function="join")
+        func = load_python_function(config)
+        assert callable(func)
+        assert func("a", "b") == "a/b"
+
+    def test_loads_json_dumps(self):
+        """Can load json.dumps."""
+        config = PythonToolConfig(module="json", function="dumps")
+        func = load_python_function(config)
+        assert func({"a": 1}) == '{"a": 1}'
+
+    def test_raises_on_invalid_module(self):
+        """Raises ImportError for non-existent module."""
+        config = PythonToolConfig(module="nonexistent.module", function="foo")
+        with pytest.raises(ImportError, match="Cannot import module"):
+            load_python_function(config)
+
+    def test_raises_on_invalid_function(self):
+        """Raises AttributeError for non-existent function."""
+        config = PythonToolConfig(module="os.path", function="nonexistent_func")
+        with pytest.raises(AttributeError, match="not found in module"):
+            load_python_function(config)
+
+    def test_raises_on_non_callable(self):
+        """Raises TypeError if attribute is not callable."""
+        config = PythonToolConfig(module="os", function="name")
+        with pytest.raises(TypeError, match="not callable"):
+            load_python_function(config)
+
+
+class TestParsePythonTools:
+    """Tests for parse_python_tools."""
+
+    def test_parses_python_tools(self):
+        """Extracts only type: python tools."""
+        tools_config = {
+            "shell_tool": {"command": "echo hello"},
+            "python_tool": {
+                "type": "python",
+                "module": "json",
+                "function": "dumps",
+            },
+        }
+        result = parse_python_tools(tools_config)
+
+        assert len(result) == 1
+        assert "python_tool" in result
+        assert result["python_tool"].module == "json"
+        assert result["python_tool"].function == "dumps"
+
+    def test_skips_shell_tools(self):
+        """Does not include shell tools."""
+        tools_config = {
+            "git_log": {
+                "type": "shell",
+                "command": "git log",
+            },
+        }
+        result = parse_python_tools(tools_config)
+        assert len(result) == 0
+
+    def test_skips_incomplete_python_tools(self):
+        """Skips Python tools missing module or function."""
+        tools_config = {
+            "missing_module": {"type": "python", "function": "foo"},
+            "missing_function": {"type": "python", "module": "json"},
+        }
+        result = parse_python_tools(tools_config)
+        assert len(result) == 0
+
+    def test_includes_description(self):
+        """Parses description field."""
+        tools_config = {
+            "my_tool": {
+                "type": "python",
+                "module": "json",
+                "function": "loads",
+                "description": "Parse JSON",
+            },
+        }
+        result = parse_python_tools(tools_config)
+        assert result["my_tool"].description == "Parse JSON"
+
+
+class TestCreatePythonNode:
+    """Tests for create_python_node."""
+
+    def test_creates_node_function(self):
+        """Creates callable node function."""
+        python_tools = {
+            "my_tool": PythonToolConfig(
+                module="tests.unit.test_python_nodes",
+                function="sample_node_function",
+            ),
+        }
+        node_config = {"tool": "my_tool", "state_key": "result"}
+
+        node_fn = create_python_node("test_node", node_config, python_tools)
+        assert callable(node_fn)
+
+    def test_raises_on_missing_tool(self):
+        """Raises if tool not in registry."""
+        python_tools = {}
+        node_config = {"tool": "nonexistent"}
+
+        with pytest.raises(KeyError, match="not found"):
+            create_python_node("test_node", node_config, python_tools)
+
+    def test_raises_on_missing_tool_key(self):
+        """Raises if node config missing tool key."""
+        python_tools = {}
+        node_config = {}
+
+        with pytest.raises(ValueError, match="must specify"):
+            create_python_node("test_node", node_config, python_tools)
+
+    def test_node_returns_dict_from_function(self):
+        """Node returns function's dict result with current_step."""
+        python_tools = {
+            "dict_tool": PythonToolConfig(
+                module="tests.unit.test_python_nodes",
+                function="sample_node_function",
+            ),
+        }
+        node_config = {"tool": "dict_tool"}
+
+        node_fn = create_python_node("test_node", node_config, python_tools)
+        result = node_fn({"input": "hello"})
+
+        assert result["current_step"] == "test_node"
+        assert "output" in result
+
+    def test_node_wraps_non_dict_return(self):
+        """Node wraps non-dict return in state_key."""
+        python_tools = {
+            "scalar_tool": PythonToolConfig(
+                module="tests.unit.test_python_nodes",
+                function="scalar_return_function",
+            ),
+        }
+        node_config = {"tool": "scalar_tool", "state_key": "my_value"}
+
+        node_fn = create_python_node("test_node", node_config, python_tools)
+        result = node_fn({})
+
+        assert result["my_value"] == 42
+        assert result["current_step"] == "test_node"
+
+
+# Sample functions for testing
+def sample_node_function(state: dict) -> dict:
+    """Sample node function that returns a dict."""
+    return {"output": f"processed: {state.get('input', 'none')}"}
+
+
+def scalar_return_function(state: dict) -> int:
+    """Sample function that returns a scalar."""
+    return 42