yamlgraph 0.3.9__py3-none-any.whl

examples/codegen/tests/test_meta_tools.py

@@ -0,0 +1,250 @@
+"""Tests for YAMLGraph meta-template tools."""
+
+from pathlib import Path
+
+from examples.codegen.tools.meta_tools import (
+    extract_graph_template,
+    extract_prompt_template,
+)
+
+# ============================================================================
+# extract_graph_template tests
+# ============================================================================
+
+
+class TestExtractGraphTemplate:
+    """Tests for extract_graph_template."""
+
+    def test_extracts_node_types(self, tmp_path: Path):
+        """Extract node type patterns from graph."""
+        graph = tmp_path / "graph.yaml"
+        graph.write_text("""
+name: test-graph
+version: "1.0"
+
+nodes:
+  step1:
+    type: llm
+    prompt: prompts/step1
+    state_key: result1
+
+  step2:
+    type: agent
+    prompt: prompts/step2
+    tools: [tool1, tool2]
+    max_iterations: 5
+
+edges:
+  - START -> step1
+  - step1 -> step2
+  - step2 -> END
+""")
+        result = extract_graph_template(str(graph))
+
+        assert "node_types" in result
+        assert "llm" in result["node_types"]
+        assert "agent" in result["node_types"]
+
+    def test_extracts_edge_patterns(self, tmp_path: Path):
+        """Extract edge patterns (sequential, conditional)."""
+        graph = tmp_path / "graph.yaml"
+        graph.write_text("""
+name: conditional-graph
+
+nodes:
+  check:
+    type: llm
+    prompt: check
+  branch_a:
+    type: llm
+    prompt: a
+  branch_b:
+    type: llm
+    prompt: b
+
+edges:
+  - START -> check
+  - check -> branch_a:
+      condition: state.result == "a"
+  - check -> branch_b:
+      condition: state.result == "b"
+  - branch_a -> END
+  - branch_b -> END
+""")
+        result = extract_graph_template(str(graph))
+
+        assert "edge_patterns" in result
+        patterns = result["edge_patterns"]
+        assert "conditional" in patterns or any("condition" in str(p) for p in patterns)
+
+    def test_extracts_state_fields(self, tmp_path: Path):
+        """Extract state field patterns."""
+        graph = tmp_path / "graph.yaml"
+        graph.write_text("""
+name: stateful-graph
+
+state:
+  input: str
+  results: list
+  errors: list[PipelineError]
+
+nodes:
+  process:
+    type: llm
+    prompt: process
+    state_key: results
+""")
+        result = extract_graph_template(str(graph))
+
+        assert "state_fields" in result
+        fields = result["state_fields"]
+        assert "input" in fields or any("input" in str(f) for f in fields)
+
+    def test_extracts_tool_patterns(self, tmp_path: Path):
+        """Extract tool declaration patterns."""
+        graph = tmp_path / "graph.yaml"
+        graph.write_text("""
+name: tool-graph
+
+tools:
+  search:
+    type: python
+    module: mymodule
+    function: search_func
+    description: "Search for things"
+
+  fetch:
+    type: shell
+    command: "curl {url}"
+
+nodes:
+  agent:
+    type: agent
+    tools: [search, fetch]
+""")
+        result = extract_graph_template(str(graph))
+
+        assert "tool_patterns" in result
+        patterns = result["tool_patterns"]
+        assert "python" in patterns or any("python" in str(p) for p in patterns)
+
+    def test_handles_missing_file(self):
+        """Returns error for missing file."""
+        result = extract_graph_template("/nonexistent/graph.yaml")
+        assert "error" in result
+
+    def test_handles_invalid_yaml(self, tmp_path: Path):
+        """Returns error for invalid YAML."""
+        graph = tmp_path / "bad.yaml"
+        graph.write_text("{ invalid yaml: [")
+
+        result = extract_graph_template(str(graph))
+        assert "error" in result
+
+
+# ============================================================================
+# extract_prompt_template tests
+# ============================================================================
+
+
+class TestExtractPromptTemplate:
+    """Tests for extract_prompt_template."""
+
+    def test_extracts_system_structure(self, tmp_path: Path):
+        """Extract system prompt structure."""
+        prompt = tmp_path / "prompt.yaml"
+        prompt.write_text("""
+metadata:
+  provider: anthropic
+  model: claude-sonnet-4-20250514
+
+system: |
+  You are an expert assistant.
+
+  ## Instructions
+  - Be helpful
+  - Be concise
+
+  ## Output Format
+  Respond in JSON.
+
+user: "Process this: {input}"
+""")
+        result = extract_prompt_template(str(prompt))
+
+        assert "system_structure" in result
+        structure = result["system_structure"]
+        assert "sections" in structure or len(structure) > 0
+
+    def test_extracts_variable_patterns(self, tmp_path: Path):
+        """Extract variable injection patterns."""
+        prompt = tmp_path / "prompt.yaml"
+        prompt.write_text("""
+system: "You are a {role} assistant."
+user: |
+  Input: {input}
+  Context: {context}
+  Previous: {history}
+""")
+        result = extract_prompt_template(str(prompt))
+
+        assert "variables" in result
+        variables = result["variables"]
+        assert "input" in variables
+        assert "context" in variables
+
+    def test_extracts_schema_patterns(self, tmp_path: Path):
+        """Extract output schema patterns."""
+        prompt = tmp_path / "prompt.yaml"
+        prompt.write_text("""
+system: "Analyze the input."
+user: "{input}"
+
+schema:
+  type: object
+  properties:
+    result:
+      type: string
+    confidence:
+      type: number
+  required: [result]
+""")
+        result = extract_prompt_template(str(prompt))
+
+        assert "schema_patterns" in result
+        patterns = result["schema_patterns"]
+        assert "result" in str(patterns) or len(patterns) > 0
+
+    def test_extracts_jinja_patterns(self, tmp_path: Path):
+        """Extract Jinja2 template patterns."""
+        prompt = tmp_path / "prompt.yaml"
+        prompt.write_text("""
+system: |
+  {% if context %}
+  Context: {{ context }}
+  {% endif %}
+
+  {% for item in items %}
+  - {{ item.name }}: {{ item.value }}
+  {% endfor %}
+
+user: "Process {{ input }}"
+""")
+        result = extract_prompt_template(str(prompt))
+
+        assert "jinja_patterns" in result
+        patterns = result["jinja_patterns"]
+        assert "if" in patterns or "for" in patterns
+
+    def test_handles_missing_file(self):
+        """Returns error for missing file."""
+        result = extract_prompt_template("/nonexistent/prompt.yaml")
+        assert "error" in result
+
+    def test_handles_invalid_yaml(self, tmp_path: Path):
+        """Returns error for invalid YAML."""
+        prompt = tmp_path / "bad.yaml"
+        prompt.write_text("{ invalid yaml: [")
+
+        result = extract_prompt_template(str(prompt))
+        assert "error" in result

examples/codegen/tests/test_plan_discovery_prompt.py

@@ -0,0 +1,98 @@
+"""Tests for plan_discovery prompt."""
+
+from pathlib import Path
+
+from examples.codegen.models.schemas import DiscoveryPlan, DiscoveryTask
+from yamlgraph.utils.prompts import load_prompt
+
+
+class TestPlanDiscoveryPrompt:
+    """Tests for plan_discovery.yaml prompt structure."""
+
+    def test_prompt_file_exists(self):
+        """Prompt file exists and is loadable."""
+        prompt_path = Path("examples/codegen/prompts/plan_discovery.yaml")
+        assert prompt_path.exists(), "plan_discovery.yaml not found"
+
+        prompt = load_prompt("examples/codegen/plan_discovery")
+        assert "system" in prompt
+        assert "user" in prompt
+        assert "schema" in prompt
+
+    def test_prompt_has_required_sections(self):
+        """Prompt contains key instruction sections."""
+        prompt = load_prompt("examples/codegen/plan_discovery")
+        system = prompt["system"]
+
+        # Check for key sections
+        assert "Available Tools" in system
+        assert "Minimum Checklist" in system
+        assert "Priority" in system
+
+    def test_prompt_lists_core_tools(self):
+        """Prompt documents core discovery tools."""
+        prompt = load_prompt("examples/codegen/plan_discovery")
+        system = prompt["system"]
+
+        # Core tools should be listed
+        assert "list_modules" in system
+        assert "get_structure" in system
+        assert "find_tests" in system
+        assert "get_callers" in system
+        assert "find_similar_code" in system
+
+    def test_schema_matches_discovery_plan(self):
+        """Output schema is compatible with DiscoveryPlan model."""
+        prompt = load_prompt("examples/codegen/plan_discovery")
+        schema = prompt["schema"]
+
+        # Schema should have name and define tasks field
+        assert "name" in schema
+        assert schema["name"] == "DiscoveryPlan"
+        assert "fields" in schema
+        assert "tasks" in schema["fields"]
+
+    def test_discovery_plan_accepts_valid_output(self):
+        """DiscoveryPlan can parse expected LLM output format."""
+        # Simulate LLM output
+        llm_output = {
+            "tasks": [
+                {
+                    "id": 1,
+                    "task": "Find websearch module structure",
+                    "tool": "get_structure",
+                    "args": {"file_path": "yamlgraph/tools/websearch.py"},
+                    "rationale": "Locate target function",
+                    "priority": 1,
+                },
+                {
+                    "id": 2,
+                    "task": "Find callers of websearch",
+                    "tool": "get_callers",
+                    "args": {
+                        "file_path": "yamlgraph/tools/websearch.py",
+                        "function_name": "websearch",
+                        "line": 10,
+                    },
+                    "rationale": "Understand dependencies",
+                    "priority": 2,
+                },
+            ]
+        }
+
+        # Should parse successfully
+        plan = DiscoveryPlan(tasks=[DiscoveryTask(**t) for t in llm_output["tasks"]])
+        assert len(plan.tasks) == 2
+        assert plan.tasks[0].tool == "get_structure"
+        assert plan.tasks[1].priority == 2
+
+    def test_minimum_checklist_coverage(self):
+        """Prompt explicitly requires minimum discovery coverage."""
+        prompt = load_prompt("examples/codegen/plan_discovery")
+        system = prompt["system"]
+
+        # Minimum checklist items
+        assert "Location" in system
+        assert "Dependencies" in system
+        assert "Tests" in system
+        assert "Patterns" in system

examples/codegen/tests/test_syntax_tools.py

@@ -0,0 +1,85 @@
+"""Tests for syntax validation tools."""
+
+from examples.codegen.tools.syntax_tools import syntax_check
+
+
+class TestSyntaxCheck:
+    """Tests for syntax_check function."""
+
+    def test_valid_python_returns_valid(self):
+        """Valid Python code returns valid=True."""
+        code = "def hello():\n    return 'world'"
+        result = syntax_check(code)
+
+        assert result["valid"] is True
+        assert "error" not in result
+
+    def test_valid_class_definition(self):
+        """Valid class definition passes."""
+        code = """
+class MyClass:
+    def __init__(self, name: str):
+        self.name = name
+
+    def greet(self) -> str:
+        return f"Hello, {self.name}"
+"""
+        result = syntax_check(code)
+        assert result["valid"] is True
+
+    def test_invalid_syntax_returns_error(self):
+        """Invalid syntax returns valid=False with error."""
+        code = "def broken(\n    return"
+        result = syntax_check(code)
+
+        assert result["valid"] is False
+        assert "error" in result
+        assert isinstance(result["error"], str)
+
+    def test_missing_colon_error(self):
+        """Missing colon is detected."""
+        code = "if True\n    print('oops')"
+        result = syntax_check(code)
+
+        assert result["valid"] is False
+        assert "error" in result
+
+    def test_indentation_error(self):
+        """Indentation errors are detected."""
+        code = "def foo():\nreturn 1"
+        result = syntax_check(code)
+
+        assert result["valid"] is False
+        assert "error" in result
+
+    def test_empty_string_is_valid(self):
+        """Empty string is valid Python."""
+        result = syntax_check("")
+        assert result["valid"] is True
+
+    def test_comment_only_is_valid(self):
+        """Comment-only code is valid."""
+        code = "# Just a comment"
+        result = syntax_check(code)
+        assert result["valid"] is True
+
+    def test_import_statement_valid(self):
+        """Import statements are valid."""
+        code = "from typing import Optional\nimport os"
+        result = syntax_check(code)
+        assert result["valid"] is True
+
+    def test_error_includes_line_number(self):
+        """Error message includes line information."""
+        code = "line1 = 1\nline2 =\nline3 = 3"
+        result = syntax_check(code)
+
+        assert result["valid"] is False
+        # Error should mention line 2
+        assert "line" in result["error"].lower() or "2" in result["error"]
+
+    def test_multiline_string_valid(self):
+        """Multiline strings are valid."""
+        code = '"""This is a\nmultiline\ndocstring."""'
+        result = syntax_check(code)
+        assert result["valid"] is True

examples/codegen/tests/test_synthesize_prompt.py

@@ -0,0 +1,94 @@
+"""Tests for synthesize prompt.
+
+TDD Phase 4: LLM combines discovery findings into analysis.
+"""
+
+from pathlib import Path
+
+import pytest
+import yaml
+
+PROMPT_PATH = Path(__file__).parent.parent / "prompts" / "synthesize.yaml"
+
+
+class TestSynthesizePromptStructure:
+    """Test prompt file structure and content."""
+
+    @pytest.fixture
+    def prompt_content(self) -> dict:
+        """Load the prompt YAML."""
+        assert PROMPT_PATH.exists(), f"Prompt not found: {PROMPT_PATH}"
+        with open(PROMPT_PATH) as f:
+            return yaml.safe_load(f)
+
+    def test_has_required_sections(self, prompt_content):
+        """Should have system, user, and schema sections."""
+        assert "system" in prompt_content
+        assert "user" in prompt_content
+        assert "schema" in prompt_content
+
+    def test_has_metadata(self, prompt_content):
+        """Should have metadata with description and model."""
+        assert "metadata" in prompt_content
+        metadata = prompt_content["metadata"]
+        assert "description" in metadata
+        assert "model" in metadata or "provider" in metadata
+
+    def test_system_covers_focus_areas(self, prompt_content):
+        """System prompt should mention key focus areas."""
+        system = prompt_content["system"].lower()
+        # Must analyze these aspects
+        assert "file" in system or "target" in system
+        assert "depend" in system or "caller" in system
+        assert "test" in system
+        assert "pattern" in system
+
+    def test_user_includes_discovery_findings(self, prompt_content):
+        """User template should include discovery_findings variable."""
+        user = prompt_content["user"]
+        assert "{discovery_findings}" in user or "discovery_findings" in user
+
+    def test_user_includes_story(self, prompt_content):
+        """User template should include story context."""
+        user = prompt_content["user"]
+        assert "{story}" in user or "story" in user
+
+
+class TestSynthesizeSchema:
+    """Test the output schema structure."""
+
+    @pytest.fixture
+    def schema(self) -> dict:
+        """Load the schema from prompt."""
+        with open(PROMPT_PATH) as f:
+            content = yaml.safe_load(f)
+        return content.get("schema", {})
+
+    def test_schema_has_name(self, schema):
+        """Schema should have a name."""
+        assert "name" in schema
+
+    def test_schema_has_summary(self, schema):
+        """Schema should include summary field."""
+        fields = schema.get("fields", {})
+        assert "summary" in fields
+
+    def test_schema_has_target_files(self, schema):
+        """Schema should include target_files array."""
+        fields = schema.get("fields", {})
+        assert "target_files" in fields
+
+    def test_schema_has_dependencies(self, schema):
+        """Schema should include dependencies."""
+        fields = schema.get("fields", {})
+        assert "dependencies" in fields
+
+    def test_schema_has_test_coverage(self, schema):
+        """Schema should include test coverage info."""
+        fields = schema.get("fields", {})
+        assert "test_coverage" in fields
+
+    def test_schema_has_patterns(self, schema):
+        """Schema should include patterns to follow."""
+        fields = schema.get("fields", {})
+        assert "patterns_to_follow" in fields