yamlgraph 0.3.9__py3-none-any.whl

tests/unit/test_feature_brainstorm.py

@@ -0,0 +1,194 @@
+"""Tests for feature-brainstorm graph.
+
+TDD: Write tests first, then implement graph and prompts.
+"""
+
+from pathlib import Path
+
+import yaml
+
+from yamlgraph.tools.graph_linter import lint_graph
+
+# Use absolute paths relative to project root
+PROJECT_ROOT = Path(__file__).parent.parent.parent
+GRAPH_PATH = PROJECT_ROOT / "graphs/feature-brainstorm.yaml"
+PROMPTS_DIR = PROJECT_ROOT / "prompts/feature-brainstorm"
+
+
+class TestFeatureBrainstormStructure:
+    """Test graph file structure and validity."""
+
+    def test_graph_file_exists(self):
+        """Graph file should exist."""
+        assert GRAPH_PATH.exists(), f"Missing {GRAPH_PATH}"
+
+    def test_graph_passes_linter(self):
+        """Graph should pass all lint checks."""
+        result = lint_graph(GRAPH_PATH, project_root=PROJECT_ROOT)
+        assert result.valid, f"Lint errors: {[i.message for i in result.issues]}"
+
+    def test_graph_has_required_fields(self):
+        """Graph should have name, description, state, tools, nodes, edges."""
+        with open(GRAPH_PATH) as f:
+            graph = yaml.safe_load(f)
+
+        assert "name" in graph, "Missing 'name'"
+        assert "description" in graph, "Missing 'description'"
+        assert "state" in graph, "Missing 'state'"
+        assert "tools" in graph, "Missing 'tools'"
+        assert "nodes" in graph, "Missing 'nodes'"
+        assert "edges" in graph, "Missing 'edges'"
+
+    def test_graph_has_focus_state_variable(self):
+        """Graph should have optional 'focus' state variable."""
+        with open(GRAPH_PATH) as f:
+            graph = yaml.safe_load(f)
+
+        state = graph.get("state", {})
+        assert "focus" in state, "Missing 'focus' in state"
+
+
+class TestFeatureBrainstormTools:
+    """Test tool definitions."""
+
+    def test_has_codebase_reading_tools(self):
+        """Graph should have tools to read codebase."""
+        with open(GRAPH_PATH) as f:
+            graph = yaml.safe_load(f)
+
+        tools = graph.get("tools", {})
+        tool_names = set(tools.keys())
+
+        # Should have at least these for context gathering
+        expected = {"read_patterns", "read_readme", "search_todos"}
+        missing = expected - tool_names
+        assert not missing, f"Missing tools: {missing}"
+
+    def test_has_websearch_tool(self):
+        """Graph should have websearch tool for research."""
+        with open(GRAPH_PATH) as f:
+            graph = yaml.safe_load(f)
+
+        tools = graph.get("tools", {})
+
+        # Find websearch tool
+        websearch_tools = [
+            name for name, config in tools.items() if config.get("type") == "websearch"
+        ]
+        assert websearch_tools, "Missing websearch tool"
+
+
+class TestFeatureBrainstormNodes:
+    """Test node definitions."""
+
+    def test_has_gather_context_node(self):
+        """Graph should have gather_context agent node."""
+        with open(GRAPH_PATH) as f:
+            graph = yaml.safe_load(f)
+
+        nodes = graph.get("nodes", {})
+        assert "gather_context" in nodes, "Missing 'gather_context' node"
+        assert nodes["gather_context"]["type"] == "agent"
+
+    def test_has_research_node(self):
+        """Graph should have research agent node."""
+        with open(GRAPH_PATH) as f:
+            graph = yaml.safe_load(f)
+
+        nodes = graph.get("nodes", {})
+        assert "research_alternatives" in nodes, "Missing 'research_alternatives' node"
+
+    def test_has_brainstorm_node(self):
+        """Graph should have brainstorm LLM node."""
+        with open(GRAPH_PATH) as f:
+            graph = yaml.safe_load(f)
+
+        nodes = graph.get("nodes", {})
+        assert "brainstorm" in nodes, "Missing 'brainstorm' node"
+        assert nodes["brainstorm"]["type"] == "llm"
+
+    def test_has_prioritize_node(self):
+        """Graph should have prioritize LLM node."""
+        with open(GRAPH_PATH) as f:
+            graph = yaml.safe_load(f)
+
+        nodes = graph.get("nodes", {})
+        assert "prioritize" in nodes, "Missing 'prioritize' node"
+
+
+class TestFeatureBrainstormPrompts:
+    """Test prompt files exist and are valid."""
+
+    def test_prompts_directory_exists(self):
+        """Prompts directory should exist."""
+        assert PROMPTS_DIR.exists(), f"Missing {PROMPTS_DIR}"
+
+    def test_gather_prompt_exists(self):
+        """gather.yaml prompt should exist."""
+        prompt_path = PROMPTS_DIR / "gather.yaml"
+        assert prompt_path.exists(), f"Missing {prompt_path}"
+
+    def test_research_prompt_exists(self):
+        """research.yaml prompt should exist."""
+        prompt_path = PROMPTS_DIR / "research.yaml"
+        assert prompt_path.exists(), f"Missing {prompt_path}"
+
+    def test_ideate_prompt_exists(self):
+        """ideate.yaml prompt should exist."""
+        prompt_path = PROMPTS_DIR / "ideate.yaml"
+        assert prompt_path.exists(), f"Missing {prompt_path}"
+
+    def test_prioritize_prompt_exists(self):
+        """prioritize.yaml prompt should exist."""
+        prompt_path = PROMPTS_DIR / "prioritize.yaml"
+        assert prompt_path.exists(), f"Missing {prompt_path}"
+
+    def test_prompts_have_required_fields(self):
+        """All prompts should have system and user fields."""
+        for prompt_file in PROMPTS_DIR.glob("*.yaml"):
+            with open(prompt_file) as f:
+                prompt = yaml.safe_load(f)
+
+            assert (
+                "system" in prompt or "user" in prompt
+            ), f"{prompt_file.name} missing 'system' or 'user'"
+
+
+class TestFeatureBrainstormEdges:
+    """Test edge definitions create valid flow."""
+
+    def test_starts_with_gather_context(self):
+        """Graph should start with gather_context."""
+        with open(GRAPH_PATH) as f:
+            graph = yaml.safe_load(f)
+
+        edges = graph.get("edges", [])
+        start_edges = [e for e in edges if e.get("from") == "START"]
+
+        assert start_edges, "Missing START edge"
+        assert start_edges[0]["to"] == "gather_context"
+
+    def test_ends_with_prioritize(self):
+        """Graph should end after prioritize."""
+        with open(GRAPH_PATH) as f:
+            graph = yaml.safe_load(f)
+
+        edges = graph.get("edges", [])
+        end_edges = [e for e in edges if e.get("to") == "END"]
+
+        assert end_edges, "Missing END edge"
+        # Last node before END should be prioritize
+        assert any(e["from"] == "prioritize" for e in end_edges)
+
+    def test_has_complete_flow(self):
+        """Graph should have edges connecting all nodes."""
+        with open(GRAPH_PATH) as f:
+            graph = yaml.safe_load(f)
+
+        edges = graph.get("edges", [])
+        nodes = set(graph.get("nodes", {}).keys())
+
+        # All nodes should be reachable (appear as 'to')
+        targets = {e["to"] for e in edges if e["to"] != "END"}
+        unreachable = nodes - targets
+        assert not unreachable, f"Unreachable nodes: {unreachable}"

tests/unit/test_format_prompt.py

@@ -0,0 +1,145 @@
+"""Tests for prompt formatting with Jinja2 support."""
+
+import pytest
+
+from yamlgraph.executor import format_prompt
+
+
+class TestFormatPrompt:
+    """Test the format_prompt function with both simple and Jinja2 templates."""
+
+    def test_simple_format_basic(self):
+        """Test basic string formatting with {variable} syntax."""
+        template = "Hello {name}!"
+        variables = {"name": "World"}
+        result = format_prompt(template, variables)
+        assert result == "Hello World!"
+
+    def test_simple_format_multiple_variables(self):
+        """Test formatting with multiple variables."""
+        template = "Topic: {topic}, Style: {style}, Words: {word_count}"
+        variables = {"topic": "AI", "style": "casual", "word_count": 500}
+        result = format_prompt(template, variables)
+        assert result == "Topic: AI, Style: casual, Words: 500"
+
+    def test_simple_format_missing_variable(self):
+        """Test that missing variables raise KeyError."""
+        template = "Hello {name}!"
+        variables = {}
+        with pytest.raises(KeyError):
+            format_prompt(template, variables)
+
+    def test_jinja2_basic_variable(self):
+        """Test Jinja2 template with basic {{ variable }} syntax."""
+        template = "Hello {{ name }}!"
+        variables = {"name": "World"}
+        result = format_prompt(template, variables)
+        assert result == "Hello World!"
+
+    def test_jinja2_for_loop(self):
+        """Test Jinja2 template with for loop."""
+        template = """{% for item in items %}
+- {{ item }}
+{% endfor %}"""
+        variables = {"items": ["apple", "banana", "cherry"]}
+        result = format_prompt(template, variables)
+        # Jinja2 preserves whitespace from template
+        assert "- apple" in result
+        assert "- banana" in result
+        assert "- cherry" in result
+
+    def test_jinja2_conditional(self):
+        """Test Jinja2 template with if/else."""
+        template = """{% if premium %}Premium User{% else %}Regular User{% endif %}"""
+
+        result_premium = format_prompt(template, {"premium": True})
+        assert result_premium == "Premium User"
+
+        result_regular = format_prompt(template, {"premium": False})
+        assert result_regular == "Regular User"
+
+    def test_jinja2_filter_slice(self):
+        """Test Jinja2 template with slice filter."""
+        template = "Summary: {{ text[:50] }}..."
+        variables = {
+            "text": "This is a very long text that should be truncated to show only first fifty characters"
+        }
+        result = format_prompt(template, variables)
+        # Check that the text is sliced to 50 characters
+        assert result.startswith(
+            "Summary: This is a very long text that should be truncated"
+        )
+        assert result.endswith("...")
+        assert len(result) < len(variables["text"]) + len("Summary: ...")
+
+    def test_jinja2_filter_upper(self):
+        """Test Jinja2 template with upper filter."""
+        template = "{{ name | upper }}"
+        variables = {"name": "world"}
+        result = format_prompt(template, variables)
+        assert result == "WORLD"
+
+    def test_jinja2_complex_template(self):
+        """Test complex Jinja2 template with loops and conditionals."""
+        template = """Items in {{ category }}:
+{% for item in items %}
+  {% if item.available %}
+  - {{ item.name }}: ${{ item.price }}
+  {% endif %}
+{% endfor %}"""
+        variables = {
+            "category": "Fruits",
+            "items": [
+                {"name": "Apple", "price": 1.50, "available": True},
+                {"name": "Banana", "price": 0.75, "available": False},
+                {"name": "Cherry", "price": 2.00, "available": True},
+            ],
+        }
+        result = format_prompt(template, variables)
+        assert "Apple: $1.5" in result
+        assert "Cherry: $2.0" in result
+        assert "Banana" not in result
+
+    def test_jinja2_missing_variable_graceful(self):
+        """Test that Jinja2 missing variables are handled (rendered as empty by default)."""
+        template = "Hello {{ name }}!"
+        variables = {}
+        result = format_prompt(template, variables)
+        # Jinja2 by default renders undefined variables as empty strings
+        assert result == "Hello !"
+
+    def test_detection_uses_jinja2_for_double_braces(self):
+        """Test that {{ triggers Jinja2 mode."""
+        template = "Value: {{ x }}"
+        variables = {"x": 42}
+        result = format_prompt(template, variables)
+        assert result == "Value: 42"
+
+    def test_detection_uses_jinja2_for_statements(self):
+        """Test that {% triggers Jinja2 mode."""
+        template = "{% if true %}Yes{% endif %}"
+        variables = {}
+        result = format_prompt(template, variables)
+        assert result == "Yes"
+
+    def test_backward_compatibility_no_jinja2_syntax(self):
+        """Test that templates without Jinja2 syntax still use simple format."""
+        # This ensures backward compatibility
+        template = "Simple {var} template"
+        variables = {"var": "test"}
+        result = format_prompt(template, variables)
+        assert result == "Simple test template"
+
+    def test_empty_template(self):
+        """Test formatting empty template."""
+        template = ""
+        variables = {}
+        result = format_prompt(template, variables)
+        assert result == ""
+
+    def test_template_with_no_placeholders(self):
+        """Test template with no variables."""
+        template = "Just plain text"
+        variables = {"unused": "value"}
+        result = format_prompt(template, variables)
+        assert result == "Just plain text"

tests/unit/test_generic_report.py

@@ -0,0 +1,200 @@
+"""Tests for Phase 6.5: Generic Report Schema.
+
+Tests for flexible GenericReport model that works for most analysis/summary tasks.
+"""
+
+import pytest
+from pydantic import ValidationError
+
+
+class TestGenericReportSchema:
+    """Tests for GenericReport model."""
+
+    def test_generic_report_exists(self):
+        """GenericReport model is importable."""
+        from yamlgraph.models.schemas import GenericReport
+
+        assert GenericReport is not None
+
+    def test_minimal_report(self):
+        """Report works with just title and summary."""
+        from yamlgraph.models.schemas import GenericReport
+
+        report = GenericReport(
+            title="Test Report",
+            summary="A brief summary of findings.",
+        )
+
+        assert report.title == "Test Report"
+        assert report.summary == "A brief summary of findings."
+
+    def test_report_with_sections(self):
+        """Sections field accepts arbitrary dict content."""
+        from yamlgraph.models.schemas import GenericReport
+
+        report = GenericReport(
+            title="Report",
+            summary="Summary",
+            sections={
+                "overview": "First section content",
+                "details": {"nested": "data", "count": 42},
+                "items": ["a", "b", "c"],
+            },
+        )
+
+        assert report.sections["overview"] == "First section content"
+        assert report.sections["details"]["count"] == 42
+        assert len(report.sections["items"]) == 3
+
+    def test_report_with_findings(self):
+        """Findings field is list of strings."""
+        from yamlgraph.models.schemas import GenericReport
+
+        report = GenericReport(
+            title="Report",
+            summary="Summary",
+            findings=["Finding 1", "Finding 2", "Finding 3"],
+        )
+
+        assert len(report.findings) == 3
+        assert "Finding 1" in report.findings
+
+    def test_report_with_recommendations(self):
+        """Recommendations field is list of strings."""
+        from yamlgraph.models.schemas import GenericReport
+
+        report = GenericReport(
+            title="Report",
+            summary="Summary",
+            recommendations=["Action 1", "Action 2"],
+        )
+
+        assert len(report.recommendations) == 2
+
+    def test_report_with_metadata(self):
+        """Metadata field accepts arbitrary key-value data."""
+        from yamlgraph.models.schemas import GenericReport
+
+        report = GenericReport(
+            title="Report",
+            summary="Summary",
+            metadata={
+                "author": "Test Author",
+                "version": 1.0,
+                "tags": ["a", "b"],
+            },
+        )
+
+        assert report.metadata["author"] == "Test Author"
+        assert report.metadata["version"] == 1.0
+
+    def test_defaults_are_empty(self):
+        """Optional fields default to empty collections."""
+        from yamlgraph.models.schemas import GenericReport
+
+        report = GenericReport(title="Report", summary="Summary")
+
+        assert report.sections == {}
+        assert report.findings == []
+        assert report.recommendations == []
+        assert report.metadata == {}
+
+    def test_title_is_required(self):
+        """Title field is required."""
+        from yamlgraph.models.schemas import GenericReport
+
+        with pytest.raises(ValidationError) as exc_info:
+            GenericReport(summary="Summary")
+
+        errors = exc_info.value.errors()
+        assert any(e["loc"] == ("title",) for e in errors)
+
+    def test_summary_is_required(self):
+        """Summary field is required."""
+        from yamlgraph.models.schemas import GenericReport
+
+        with pytest.raises(ValidationError) as exc_info:
+            GenericReport(title="Title")
+
+        errors = exc_info.value.errors()
+        assert any(e["loc"] == ("summary",) for e in errors)
+
+    def test_model_serializes_to_dict(self):
+        """Report serializes to dictionary."""
+        from yamlgraph.models.schemas import GenericReport
+
+        report = GenericReport(
+            title="Test",
+            summary="Summary",
+            findings=["A", "B"],
+        )
+
+        data = report.model_dump()
+
+        assert data["title"] == "Test"
+        assert data["summary"] == "Summary"
+        assert data["findings"] == ["A", "B"]
+
+    def test_model_serializes_to_json(self):
+        """Report serializes to JSON string."""
+        import json
+
+        from yamlgraph.models.schemas import GenericReport
+
+        report = GenericReport(title="Test", summary="Summary")
+
+        json_str = report.model_dump_json()
+        data = json.loads(json_str)
+
+        assert data["title"] == "Test"
+
+
+class TestGenericReportUseCases:
+    """Verify GenericReport works for common analysis patterns."""
+
+    def test_git_analysis_report(self):
+        """GenericReport works for git analysis output."""
+        from yamlgraph.models.schemas import GenericReport
+
+        report = GenericReport(
+            title="Git Repository Analysis",
+            summary="Analysis of recent activity in the repository.",
+            sections={
+                "commit_summary": "15 commits in last 7 days",
+                "authors": ["alice", "bob", "carol"],
+            },
+            findings=[
+                "High activity in src/core module",
+                "No tests for new features",
+                "Breaking changes in v2.0",
+            ],
+            recommendations=[
+                "Add tests for recent changes",
+                "Review breaking changes before release",
+            ],
+            metadata={
+                "repo": "langgraph-showcase",
+                "analyzed_at": "2024-01-01T00:00:00",
+            },
+        )
+
+        assert "Git Repository" in report.title
+        assert len(report.findings) == 3
+        assert report.metadata["repo"] == "langgraph-showcase"
+
+    def test_api_analysis_report(self):
+        """GenericReport works for API analysis output."""
+        from yamlgraph.models.schemas import GenericReport
+
+        report = GenericReport(
+            title="API Performance Report",
+            summary="Performance analysis of API endpoints.",
+            sections={
+                "latency": {"p50": 45, "p95": 120, "p99": 250},
+                "errors": {"rate": 0.02, "top_errors": ["500", "429"]},
+            },
+            findings=["High latency on /search endpoint"],
+            recommendations=["Add caching for /search"],
+        )
+
+        assert report.sections["latency"]["p95"] == 120