yamlgraph 0.3.9__py3-none-any.whl

examples/codegen/tests/test_git_tools.py

@@ -0,0 +1,112 @@
+"""Tests for git analysis tools."""
+
+from examples.codegen.tools.git_tools import git_blame, git_log
+
+
+class TestGitBlame:
+    """Tests for git_blame function."""
+
+    def test_returns_author_for_valid_line(self):
+        """Returns author info for a valid file/line."""
+        # Use a known file in the project
+        result = git_blame("yamlgraph/__init__.py", 1)
+
+        assert "error" not in result
+        assert "author" in result
+        assert "date" in result
+        assert "commit" in result
+        assert isinstance(result["author"], str)
+        assert len(result["author"]) > 0
+
+    def test_returns_commit_message(self):
+        """Returns commit message summary."""
+        result = git_blame("yamlgraph/__init__.py", 1)
+
+        assert "error" not in result
+        assert "summary" in result
+        assert isinstance(result["summary"], str)
+
+    def test_returns_error_for_invalid_file(self):
+        """Returns error for non-existent file."""
+        result = git_blame("nonexistent/file.py", 1)
+
+        assert "error" in result
+        assert (
+            "not found" in result["error"].lower() or "fatal" in result["error"].lower()
+        )
+
+    def test_returns_error_for_invalid_line(self):
+        """Returns error for line beyond file length."""
+        result = git_blame("yamlgraph/__init__.py", 99999)
+
+        assert "error" in result
+
+    def test_returns_line_content(self):
+        """Returns the actual line content."""
+        result = git_blame("yamlgraph/__init__.py", 1)
+
+        assert "error" not in result
+        assert "line_content" in result
+        assert isinstance(result["line_content"], str)
+
+
+class TestGitLog:
+    """Tests for git_log function."""
+
+    def test_returns_recent_commits(self):
+        """Returns list of recent commits for file."""
+        result = git_log("yamlgraph/__init__.py")
+
+        assert "error" not in result
+        assert "commits" in result
+        assert isinstance(result["commits"], list)
+        assert len(result["commits"]) > 0
+
+    def test_each_commit_has_required_fields(self):
+        """Each commit has hash, author, date, message."""
+        result = git_log("yamlgraph/__init__.py")
+
+        assert "error" not in result
+        for commit in result["commits"]:
+            assert "hash" in commit
+            assert "author" in commit
+            assert "date" in commit
+            assert "message" in commit
+
+    def test_respects_n_limit(self):
+        """Returns at most n commits."""
+        result = git_log("yamlgraph/__init__.py", n=2)
+
+        assert "error" not in result
+        assert len(result["commits"]) <= 2
+
+    def test_returns_error_for_invalid_file(self):
+        """Returns error for non-existent file."""
+        result = git_log("nonexistent/file.py")
+
+        assert "error" in result
+
+    def test_returns_error_for_untracked_file(self):
+        """Returns error for file not in git."""
+        # Create a temp file that won't be tracked
+        import tempfile
+        from pathlib import Path
+
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
+            f.write(b"# temp file")
+            temp_path = f.name
+
+        try:
+            result = git_log(temp_path)
+            # Should either error or return empty commits
+            assert "error" in result or len(result.get("commits", [])) == 0
+        finally:
+            Path(temp_path).unlink()
+
+    def test_default_n_is_5(self):
+        """Default returns up to 5 commits."""
+        result = git_log("yamlgraph/__init__.py")
+
+        assert "error" not in result
+        # Can be less than 5 if file has fewer commits
+        assert len(result["commits"]) <= 5

examples/codegen/tests/test_impl_agent_schemas.py

@@ -0,0 +1,193 @@
+"""Tests for impl-agent discovery schemas."""
+
+import pytest
+from pydantic import ValidationError
+
+from examples.codegen.models.schemas import (
+    DiscoveryFindings,
+    DiscoveryPlan,
+    DiscoveryResult,
+    DiscoveryTask,
+)
+
+
+class TestDiscoveryTask:
+    """Tests for DiscoveryTask model."""
+
+    def test_valid_task(self):
+        """Create a valid discovery task."""
+        task = DiscoveryTask(
+            id=1,
+            task="Find websearch function",
+            tool="get_structure",
+            args={"file_path": "yamlgraph/tools/websearch.py"},
+            rationale="Need to locate the target function",
+        )
+        assert task.id == 1
+        assert task.tool == "get_structure"
+        assert task.status == "pending"  # default
+        assert task.priority == 1  # default
+
+    def test_task_with_all_fields(self):
+        """Create task with explicit status and priority."""
+        task = DiscoveryTask(
+            id=2,
+            task="Find callers",
+            tool="get_callers",
+            args={"function_name": "websearch"},
+            rationale="Identify dependencies",
+            status="done",
+            priority=2,
+        )
+        assert task.status == "done"
+        assert task.priority == 2
+
+    def test_invalid_status(self):
+        """Reject invalid status values."""
+        with pytest.raises(ValidationError):
+            DiscoveryTask(
+                id=1,
+                task="Test",
+                tool="test_tool",
+                args={},
+                rationale="Test",
+                status="invalid_status",
+            )
+
+    def test_missing_required_fields(self):
+        """Require all mandatory fields."""
+        with pytest.raises(ValidationError):
+            DiscoveryTask(id=1, task="Test")  # missing tool, args, rationale
+
+
+class TestDiscoveryResult:
+    """Tests for DiscoveryResult model."""
+
+    def test_successful_result(self):
+        """Create a successful discovery result."""
+        result = DiscoveryResult(
+            task_id=1,
+            tool="get_structure",
+            success=True,
+            result={"classes": [], "functions": ["websearch"]},
+        )
+        assert result.success is True
+        assert result.error is None
+
+    def test_failed_result(self):
+        """Create a failed discovery result."""
+        result = DiscoveryResult(
+            task_id=2,
+            tool="get_callers",
+            success=False,
+            result=None,
+            error="Function not found",
+        )
+        assert result.success is False
+        assert result.error == "Function not found"
+
+    def test_result_serialization(self):
+        """Result can be serialized to dict."""
+        result = DiscoveryResult(
+            task_id=1,
+            tool="find_tests",
+            success=True,
+            result=["test_websearch.py"],
+        )
+        data = result.model_dump()
+        assert data["task_id"] == 1
+        assert data["result"] == ["test_websearch.py"]
+
+
+class TestDiscoveryPlan:
+    """Tests for DiscoveryPlan model."""
+
+    def test_plan_with_multiple_tasks(self):
+        """Create a plan with multiple tasks."""
+        plan = DiscoveryPlan(
+            tasks=[
+                DiscoveryTask(
+                    id=1,
+                    task="Find target",
+                    tool="get_structure",
+                    args={"file_path": "test.py"},
+                    rationale="Locate code",
+                ),
+                DiscoveryTask(
+                    id=2,
+                    task="Find callers",
+                    tool="get_callers",
+                    args={"function_name": "test"},
+                    rationale="Find dependencies",
+                    priority=2,
+                ),
+            ]
+        )
+        assert len(plan.tasks) == 2
+        assert plan.tasks[0].priority == 1
+        assert plan.tasks[1].priority == 2
+
+    def test_empty_plan(self):
+        """Allow empty task list."""
+        plan = DiscoveryPlan(tasks=[])
+        assert len(plan.tasks) == 0
+
+    def test_plan_serialization(self):
+        """Plan can be serialized to dict."""
+        plan = DiscoveryPlan(
+            tasks=[
+                DiscoveryTask(
+                    id=1,
+                    task="Test",
+                    tool="test",
+                    args={},
+                    rationale="Test",
+                )
+            ]
+        )
+        data = plan.model_dump()
+        assert "tasks" in data
+        assert len(data["tasks"]) == 1
+
+
+class TestDiscoveryFindings:
+    """Tests for DiscoveryFindings model."""
+
+    def test_findings_with_results(self):
+        """Create findings with multiple results."""
+        findings = DiscoveryFindings(
+            results=[
+                DiscoveryResult(
+                    task_id=1,
+                    tool="get_structure",
+                    success=True,
+                    result={"functions": ["foo"]},
+                ),
+                DiscoveryResult(
+                    task_id=2,
+                    tool="get_callers",
+                    success=False,
+                    result=None,
+                    error="Not found",
+                ),
+            ]
+        )
+        assert len(findings.results) == 2
+        assert findings.results[0].success is True
+        assert findings.results[1].success is False
+
+    def test_empty_findings(self):
+        """Allow empty results."""
+        findings = DiscoveryFindings(results=[])
+        assert len(findings.results) == 0
+
+    def test_findings_serialization(self):
+        """Findings can be serialized to dict."""
+        findings = DiscoveryFindings(
+            results=[
+                DiscoveryResult(task_id=1, tool="test", success=True, result="data")
+            ]
+        )
+        data = findings.model_dump()
+        assert "results" in data
+        assert data["results"][0]["success"] is True

examples/codegen/tests/test_impl_agent_v4_graph.py

@@ -0,0 +1,94 @@
+"""Tests for impl-agent v4 graph integration.
+
+TDD Phase 5: Wire discovery nodes into impl-agent.yaml.
+"""
+
+from pathlib import Path
+
+import pytest
+import yaml
+
+GRAPH_PATH = Path(__file__).parent.parent / "impl-agent.yaml"
+
+
+class TestImplAgentV4Structure:
+    """Test the new graph structure."""
+
+    @pytest.fixture
+    def graph_config(self) -> dict:
+        """Load the graph YAML."""
+        with open(GRAPH_PATH) as f:
+            return yaml.safe_load(f)
+
+    def test_has_plan_discovery_node(self, graph_config):
+        """Should have plan_discovery LLM node."""
+        nodes = graph_config.get("nodes", {})
+        assert "plan_discovery" in nodes
+        node = nodes["plan_discovery"]
+        assert node.get("prompt") == "examples/codegen/plan_discovery"
+        assert node.get("state_key") == "discovery_plan"
+
+    def test_has_execute_discovery_node(self, graph_config):
+        """Should have execute_discovery map node."""
+        nodes = graph_config.get("nodes", {})
+        assert "execute_discovery" in nodes
+        node = nodes["execute_discovery"]
+        assert node.get("type") == "map"
+        assert "discovery_plan" in node.get("over", "")
+        # Sub-node should be tool_call
+        sub_node = node.get("node", {})
+        assert sub_node.get("type") == "tool_call"
+
+    def test_has_synthesize_node(self, graph_config):
+        """Should have synthesize LLM node."""
+        nodes = graph_config.get("nodes", {})
+        assert "synthesize" in nodes
+        node = nodes["synthesize"]
+        assert node.get("prompt") == "examples/codegen/synthesize"
+        assert node.get("state_key") == "code_analysis"
+
+    def test_edge_flow(self, graph_config):
+        """Should have correct edge flow through discovery nodes."""
+        edges = graph_config.get("edges", [])
+
+        # Convert to from->to pairs for easier checking
+        edge_pairs = [(e["from"], e["to"]) for e in edges]
+
+        # Must have: parse_story -> plan_discovery -> execute_discovery -> synthesize -> plan
+        assert ("parse_story", "plan_discovery") in edge_pairs
+        assert ("plan_discovery", "execute_discovery") in edge_pairs
+        assert ("execute_discovery", "synthesize") in edge_pairs
+        assert ("synthesize", "plan") in edge_pairs
+
+    def test_no_agent_nodes(self, graph_config):
+        """Should not have old agent nodes (discover, analyze)."""
+        nodes = graph_config.get("nodes", {})
+        # Old agent-based discovery is replaced
+        assert "discover" not in nodes
+        assert "analyze" not in nodes
+
+
+class TestImplAgentV4State:
+    """Test state schema includes new fields."""
+
+    @pytest.fixture
+    def graph_config(self) -> dict:
+        """Load the graph YAML."""
+        with open(GRAPH_PATH) as f:
+            return yaml.safe_load(f)
+
+    def test_state_has_discovery_plan(self, graph_config):
+        """State should include discovery_plan."""
+        state = graph_config.get("state", {})
+        # Check for discovery_plan in state definition
+        assert "discovery_plan" in state or any(
+            "discovery_plan" in str(v) for v in state.values()
+        )
+
+    def test_state_has_discovery_findings(self, graph_config):
+        """State should include discovery_findings for collected results."""
+        # The collect key from map node
+        nodes = graph_config.get("nodes", {})
+        if "execute_discovery" in nodes:
+            collect_key = nodes["execute_discovery"].get("collect", "")
+            assert collect_key  # Should have a collect key

examples/codegen/tests/test_jedi_analysis.py

@@ -0,0 +1,226 @@
+"""Tests for jedi-based code analysis tools."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from examples.codegen.tools.jedi_analysis import (
+    JEDI_AVAILABLE,
+    find_references,
+    get_callees,
+    get_callers,
+)
+
+# Skip all tests if jedi not available
+pytestmark = pytest.mark.skipif(not JEDI_AVAILABLE, reason="jedi not installed")
+
+
+class TestFindReferences:
+    """Tests for find_references function."""
+
+    def test_finds_definition(self):
+        """Finds the definition of a symbol."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a simple module
+            file_path = Path(tmpdir) / "sample.py"
+            file_path.write_text("""
+class MyConfig:
+    timeout: int = 30
+
+config = MyConfig()
+print(config.timeout)
+""")
+            result = find_references(str(file_path), "MyConfig", line=2)
+
+            assert isinstance(result, list)
+            assert len(result) >= 1
+            # Should find at least the definition
+            types = [r.get("type") for r in result]
+            assert any(t in ["definition", "name"] for t in types)
+
+    def test_finds_usages_in_same_file(self):
+        """Finds usages of a symbol within the same file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "sample.py"
+            file_path.write_text("""
+def helper():
+    return 42
+
+def main():
+    x = helper()
+    y = helper()
+    return x + y
+""")
+            result = find_references(str(file_path), "helper", line=2)
+
+            assert isinstance(result, list)
+            # Should find definition + 2 usages
+            assert len(result) >= 3
+
+    def test_returns_empty_for_unknown_symbol(self):
+        """Returns empty list for non-existent symbol."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "sample.py"
+            file_path.write_text("""
+def existing_function():
+    return 42
+""")
+            # Search for a symbol that doesn't exist, on a line with a different symbol
+            result = find_references(str(file_path), "nonexistent_xyz", line=2)
+
+            assert isinstance(result, list)
+            # jedi may return what's at the position, so filter by name
+            matching = [r for r in result if r.get("name") == "nonexistent_xyz"]
+            assert len(matching) == 0
+
+    def test_returns_error_for_missing_file(self):
+        """Returns error dict for non-existent file."""
+        result = find_references("/nonexistent/file.py", "symbol", line=1)
+
+        assert isinstance(result, dict)
+        assert "error" in result
+
+    def test_finds_cross_file_references(self):
+        """Finds references across multiple files in same project."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create module with class
+            (Path(tmpdir) / "config.py").write_text("""
+class AppConfig:
+    name: str = "app"
+""")
+            # Create module that imports it
+            (Path(tmpdir) / "main.py").write_text("""
+from config import AppConfig
+
+cfg = AppConfig()
+""")
+            result = find_references(
+                str(Path(tmpdir) / "config.py"),
+                "AppConfig",
+                line=2,
+                project_path=tmpdir,
+            )
+
+            assert isinstance(result, list)
+            # Should find definition + import + usage
+            files = {r.get("file", "") for r in result}
+            assert len(files) >= 1  # At least the defining file
+
+
+class TestGetCallers:
+    """Tests for get_callers function."""
+
+    def test_finds_callers(self):
+        """Finds functions that call a given function."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "sample.py"
+            file_path.write_text("""
+def target_function():
+    return 42
+
+def caller_one():
+    return target_function()
+
+def caller_two():
+    x = target_function()
+    return x * 2
+
+def unrelated():
+    return 0
+""")
+            result = get_callers(str(file_path), "target_function", line=2)
+
+            assert isinstance(result, list)
+            assert len(result) >= 2
+            caller_names = [r.get("caller") for r in result]
+            assert "caller_one" in caller_names
+            assert "caller_two" in caller_names
+            assert "unrelated" not in caller_names
+
+    def test_returns_empty_for_uncalled_function(self):
+        """Returns empty list for function with no callers."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "sample.py"
+            file_path.write_text("""
+def lonely_function():
+    return 42
+""")
+            result = get_callers(str(file_path), "lonely_function", line=2)
+
+            assert isinstance(result, list)
+            assert len(result) == 0
+
+    def test_returns_error_for_missing_file(self):
+        """Returns error dict for non-existent file."""
+        result = get_callers("/nonexistent/file.py", "func", line=1)
+
+        assert isinstance(result, dict)
+        assert "error" in result
+
+
+class TestGetCallees:
+    """Tests for get_callees function."""
+
+    def test_finds_callees(self):
+        """Finds functions called by a given function."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "sample.py"
+            file_path.write_text("""
+def helper_a():
+    return 1
+
+def helper_b():
+    return 2
+
+def main_function():
+    a = helper_a()
+    b = helper_b()
+    return a + b
+""")
+            result = get_callees(str(file_path), "main_function", line=8)
+
+            assert isinstance(result, list)
+            assert len(result) >= 2
+            callee_names = [r.get("callee") for r in result]
+            assert "helper_a" in callee_names
+            assert "helper_b" in callee_names
+
+    def test_returns_empty_for_function_with_no_calls(self):
+        """Returns empty list for function that makes no calls."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "sample.py"
+            file_path.write_text("""
+def pure_function():
+    return 42
+""")
+            result = get_callees(str(file_path), "pure_function", line=2)
+
+            assert isinstance(result, list)
+            assert len(result) == 0
+
+    def test_returns_error_for_missing_file(self):
+        """Returns error dict for non-existent file."""
+        result = get_callees("/nonexistent/file.py", "func", line=1)
+
+        assert isinstance(result, dict)
+        assert "error" in result
+
+    def test_includes_line_numbers(self):
+        """Each callee includes line number where called."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "sample.py"
+            file_path.write_text("""
+def helper():
+    return 1
+
+def caller():
+    x = helper()
+    return x
+""")
+            result = get_callees(str(file_path), "caller", line=5)
+
+            assert len(result) >= 1
+            for callee in result:
+                assert "callee" in callee
+                assert "line" in callee