aiox-core 5.0.4 → 5.0.5

package/pro/squads/squad-creator-pro/scripts/tests/test_coherence_validator.py

@@ -1,212 +0,0 @@
-#!/usr/bin/env python3
-"""
-Tests for coherence-validator.py
-Run with: pytest scripts/tests/test_coherence_validator.py -v
-"""
-
-import os
-import sys
-import json
-import tempfile
-from pathlib import Path
-
-# Add parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-# Import with hyphen in name workaround
-import importlib.util
-spec = importlib.util.spec_from_file_location(
-    "coherence_validator",
-    Path(__file__).parent.parent / "coherence-validator.py"
-)
-coherence_validator = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(coherence_validator)
-
-# Import functions
-find_config_dir = coherence_validator.find_config_dir
-load_yaml = coherence_validator.load_yaml
-extract_ids = coherence_validator.extract_ids
-run_coherence_validation = coherence_validator.run_coherence_validation
-
-
-class TestLoadYaml:
-    """Tests for YAML loading"""
-
-    def test_load_valid_yaml(self):
-        """Should load valid YAML file"""
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
-            f.write('name: test\nversion: 1.0.0\n')
-            f.flush()
-
-            result = load_yaml(Path(f.name))
-            assert result is not None
-            assert result.get('name') == 'test'
-            os.unlink(f.name)
-
-    def test_load_invalid_yaml(self):
-        """Should return None for invalid YAML"""
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
-            f.write('invalid: yaml: content:\n  - bad')
-            f.flush()
-
-            result = load_yaml(Path(f.name))
-            # May return None or partial parse
-            os.unlink(f.name)
-
-    def test_load_nonexistent_file(self):
-        """Should return None for nonexistent file"""
-        result = load_yaml(Path('/nonexistent/file.yaml'))
-        assert result is None
-
-
-class TestExtractIds:
-    """Tests for ID extraction"""
-
-    def test_extract_heuristic_ids(self):
-        """Should extract heuristic IDs from nested data"""
-        data = {
-            'heuristics': [
-                {'id': 'SC_HE_001', 'name': 'Test 1'},
-                {'id': 'SC_HE_002', 'name': 'Test 2'},
-            ]
-        }
-        ids = extract_ids(data, r'SC_HE_\d+')
-        assert 'SC_HE_001' in ids
-        assert 'SC_HE_002' in ids
-
-    def test_extract_veto_ids(self):
-        """Should extract veto condition IDs"""
-        data = {
-            'veto_conditions': [
-                {'id': 'SC_VC_001'},
-                {'id': 'SC_VC_002'},
-            ]
-        }
-        ids = extract_ids(data, r'SC_VC_\d+')
-        assert 'SC_VC_001' in ids
-        assert 'SC_VC_002' in ids
-
-    def test_extract_from_nested_structure(self):
-        """Should extract IDs from deeply nested structures"""
-        data = {
-            'level1': {
-                'level2': {
-                    'items': [
-                        {'id': 'DEEP_001'},
-                        {'id': 'DEEP_002'}
-                    ]
-                }
-            }
-        }
-        ids = extract_ids(data, r'DEEP_\d+')
-        assert 'DEEP_001' in ids
-        assert 'DEEP_002' in ids
-
-    def test_empty_data(self):
-        """Should handle empty data gracefully"""
-        ids = extract_ids({}, r'TEST_\d+')
-        assert len(ids) == 0
-
-    def test_no_matches(self):
-        """Should return empty set when no matches"""
-        data = {'key': 'value', 'number': 123}
-        ids = extract_ids(data, r'PATTERN_\d+')
-        assert len(ids) == 0
-
-
-class TestCoherenceValidation:
-    """Tests for full coherence validation"""
-
-    def test_validation_with_config_dir(self):
-        """Should run validation on actual config directory"""
-        # Find the actual config directory
-        config_dir = find_config_dir()
-
-        if config_dir and config_dir.exists():
-            results = run_coherence_validation(config_dir)
-
-            # Should have expected structure
-            assert 'overall_status' in results
-            assert 'checks' in results
-            assert isinstance(results['checks'], list)
-
-    def test_validation_with_nonexistent_dir(self):
-        """Should handle nonexistent directory"""
-        with tempfile.TemporaryDirectory() as tmpdir:
-            # Empty directory - no config files
-            results = run_coherence_validation(Path(tmpdir))
-
-            # Should handle gracefully
-            assert 'overall_status' in results
-
-
-class TestIntegration:
-    """Integration tests with real squad-creator configs"""
-
-    def test_real_config_validation(self):
-        """Should validate real squad-creator config files"""
-        config_dir = find_config_dir()
-
-        if config_dir and config_dir.exists():
-            results = run_coherence_validation(config_dir)
-
-            # Print results for debugging
-            print(f"\nCoherence Validation Results:")
-            print(f"  Status: {results.get('overall_status', 'unknown')}")
-            print(f"  Checks: {len(results.get('checks', []))}")
-
-            for check in results.get('checks', []):
-                status = '✓' if check.get('status') == 'pass' else '✗'
-                print(f"  {status} {check.get('name', 'unnamed')}")
-
-            # Validation should complete without errors
-            assert 'overall_status' in results
-
-
-def run_basic_tests():
-    """Run basic tests without pytest"""
-    print("Running coherence-validator basic tests...\n")
-
-    # Test 1: Load YAML
-    print("Test 1: load_yaml")
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
-        f.write('name: test\n')
-        f.flush()
-        result = load_yaml(Path(f.name))
-        assert result is not None, "Failed to load YAML"
-        os.unlink(f.name)
-    print("  ✓ YAML loading works")
-
-    # Test 2: Extract IDs
-    print("Test 2: extract_ids")
-    data = {'items': [{'id': 'TEST_001'}, {'id': 'TEST_002'}]}
-    ids = extract_ids(data, r'TEST_\d+')
-    assert 'TEST_001' in ids, "Failed to extract ID"
-    print("  ✓ ID extraction works")
-
-    # Test 3: Config dir finding
-    print("Test 3: find_config_dir")
-    config_dir = find_config_dir()
-    print(f"  Config dir: {config_dir}")
-    print("  ✓ Config dir finding works")
-
-    # Test 4: Full validation (if config exists)
-    print("Test 4: run_coherence_validation")
-    if config_dir and config_dir.exists():
-        results = run_coherence_validation(config_dir)
-        print(f"  Status: {results.get('overall_status', 'unknown')}")
-        print(f"  Checks: {len(results.get('checks', []))}")
-        print("  ✓ Coherence validation works")
-    else:
-        print("  ⚠ Skipped (no config dir)")
-
-    print("\n✅ All basic tests passed!")
-
-
-if __name__ == "__main__":
-    try:
-        import pytest
-        pytest.main([__file__, "-v"])
-    except ImportError:
-        # Run basic tests without pytest
-        run_basic_tests()

package/pro/squads/squad-creator-pro/scripts/tests/test_dependency_check.py

@@ -1,361 +0,0 @@
-#!/usr/bin/env python3
-"""
-Tests for dependency_check.py
-Run with: pytest scripts/tests/test_dependency_check.py -v
-"""
-
-import os
-import sys
-import pytest
-from pathlib import Path
-
-# Add parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from dependency_check import (
-    is_in_code_block,
-    is_example_reference,
-    is_external_squad_reference,
-    extract_references,
-    check_references,
-    scan_file,
-    scan_squad,
-)
-
-
-class TestIsInCodeBlock:
-    """Tests for is_in_code_block function"""
-
-    def test_in_code_block(self):
-        """Position inside code block returns True"""
-        content = """
-Some text here.
-
-```yaml
-tasks/create-task.md
-```
-
-More text.
-"""
-        # Position of 'tasks/' in the code block
-        pos = content.find("tasks/create")
-        result = is_in_code_block(content, pos)
-
-        assert result == True
-
-    def test_outside_code_block(self):
-        """Position outside code block returns False"""
-        content = """
-Reference to tasks/create-task.md here.
-
-```yaml
-other: content
-```
-"""
-        # Position of 'tasks/' outside code block
-        pos = content.find("tasks/create")
-        result = is_in_code_block(content, pos)
-
-        assert result == False
-
-    def test_no_code_blocks(self):
-        """Content without code blocks returns False"""
-        content = "Reference to tasks/create-task.md here."
-        pos = content.find("tasks/")
-        result = is_in_code_block(content, pos)
-
-        assert result == False
-
-
-class TestIsExampleReference:
-    """Tests for is_example_reference function"""
-
-    def test_example_reference(self):
-        """Reference in example context returns True"""
-        content = """
-For example: tasks/example-task.md
-"""
-        pos = content.find("tasks/example")
-        result = is_example_reference(content, pos)
-
-        assert result == True
-
-    def test_example_with_eg(self):
-        """Reference with e.g. returns True"""
-        content = """
-You can use files like (e.g. tasks/sample.md)
-"""
-        pos = content.find("tasks/sample")
-        result = is_example_reference(content, pos)
-
-        assert result == True
-
-    def test_real_reference(self):
-        """Reference not in example context returns False"""
-        content = """
-This task depends on tasks/real-dependency.md
-"""
-        pos = content.find("tasks/real")
-        result = is_example_reference(content, pos)
-
-        assert result == False
-
-
-class TestExtractReferences:
-    """Tests for extract_references function"""
-
-    def test_extract_task_references(self):
-        """Task references are extracted"""
-        content = """
-This depends on tasks/create-task.md and tasks/validate-task.md
-"""
-        internal, external = extract_references(content, "test.md", "test-squad")
-
-        assert "create-task.md" in internal["tasks"]
-        assert "validate-task.md" in internal["tasks"]
-
-    def test_extract_agent_references(self):
-        """Agent references are extracted"""
-        content = """
-Handoff to agents/expert-agent.md
-"""
-        internal, external = extract_references(content, "test.md", "test-squad")
-
-        assert "expert-agent.md" in internal["agents"]
-
-    def test_extract_template_references(self):
-        """Template references are extracted"""
-        content = """
-Use templates/output-tmpl.yaml
-"""
-        internal, external = extract_references(content, "test.md", "test-squad")
-
-        assert "output-tmpl.yaml" in internal["templates"]
-
-    def test_extract_workflow_references(self):
-        """Workflow references are extracted"""
-        content = """
-Execute workflows/main-workflow.yaml
-"""
-        internal, external = extract_references(content, "test.md", "test-squad")
-
-        assert "main-workflow.yaml" in internal["workflows"]
-
-    def test_exclude_code_block_references(self):
-        """References in code blocks go to external"""
-        content = """
-Real reference: tasks/real.md
-
-```yaml
-# Example
-tasks/example.md
-```
-"""
-        internal, external = extract_references(content, "test.md", "test-squad")
-
-        assert "real.md" in internal["tasks"]
-        assert "example.md" in external["tasks"]
-
-    def test_relative_path_references(self):
-        """Relative path references are extracted"""
-        content = """
-Use ./tasks/local-task.md
-"""
-        internal, external = extract_references(content, "test.md", "test-squad")
-
-        assert "local-task.md" in internal["tasks"]
-
-
-class TestCheckReferences:
-    """Tests for check_references function"""
-
-    def test_check_references_all_exist(self, tmp_path):
-        """No issues when all references exist"""
-        squad_dir = tmp_path / "test-squad"
-        squad_dir.mkdir()
-
-        tasks_dir = squad_dir / "tasks"
-        tasks_dir.mkdir()
-        (tasks_dir / "existing-task.md").write_text("# Task")
-
-        references = {"tasks": ["existing-task.md"]}
-        issues = check_references(str(squad_dir), references, "source.md")
-
-        assert len(issues) == 0
-
-    def test_check_references_missing(self, tmp_path):
-        """Issues reported for missing references"""
-        squad_dir = tmp_path / "test-squad"
-        squad_dir.mkdir()
-        (squad_dir / "tasks").mkdir()
-
-        references = {"tasks": ["missing-task.md"]}
-        issues = check_references(str(squad_dir), references, "source.md")
-
-        assert len(issues) == 1
-        assert issues[0]["type"] == "MISSING_REFERENCE"
-        assert "missing-task.md" in issues[0]["referenced_file"]
-
-
-class TestScanFile:
-    """Tests for scan_file function"""
-
-    def test_scan_file_with_references(self, tmp_path):
-        """File with references is scanned correctly"""
-        squad_dir = tmp_path / "test-squad"
-        squad_dir.mkdir()
-
-        agents_dir = squad_dir / "agents"
-        agents_dir.mkdir()
-
-        agent_content = """# Test Agent
-
-Depends on tasks/helper-task.md
-"""
-        agent_file = agents_dir / "test-agent.md"
-        agent_file.write_text(agent_content)
-
-        # Create the referenced task
-        tasks_dir = squad_dir / "tasks"
-        tasks_dir.mkdir()
-        (tasks_dir / "helper-task.md").write_text("# Helper")
-
-        result = scan_file(str(agent_file), str(squad_dir), "test-squad")
-
-        assert result["file"] == "test-agent.md"
-        assert "helper-task.md" in result["references"]["tasks"]
-        assert len(result["issues"]) == 0
-
-    def test_scan_file_missing_reference(self, tmp_path):
-        """File with missing reference reports issue"""
-        squad_dir = tmp_path / "test-squad"
-        squad_dir.mkdir()
-
-        agents_dir = squad_dir / "agents"
-        agents_dir.mkdir()
-
-        agent_content = """# Test Agent
-
-Uses tasks/nonexistent.md
-"""
-        agent_file = agents_dir / "test-agent.md"
-        agent_file.write_text(agent_content)
-
-        (squad_dir / "tasks").mkdir()
-
-        result = scan_file(str(agent_file), str(squad_dir), "test-squad")
-
-        assert len(result["issues"]) == 1
-        assert result["issues"][0]["type"] == "MISSING_REFERENCE"
-
-    def test_scan_file_nonexistent(self, tmp_path):
-        """Nonexistent file returns error"""
-        result = scan_file(
-            str(tmp_path / "nonexistent.md"),
-            str(tmp_path),
-            "test-squad"
-        )
-
-        assert "error" in result
-
-
-class TestScanSquad:
-    """Tests for scan_squad function"""
-
-    def test_scan_squad_nonexistent(self, tmp_path):
-        """Nonexistent squad returns error"""
-        result = scan_squad(str(tmp_path / "nonexistent"))
-
-        assert result["exists"] == False
-        assert "error" in result
-
-    def test_scan_squad_complete(self, sample_squad):
-        """Complete squad is scanned"""
-        result = scan_squad(str(sample_squad))
-
-        assert result["exists"] == True
-        assert result["squad_name"] == "sample-squad"
-        assert "files_scanned" in result
-        assert "total_issues" in result
-        assert "status" in result
-
-    def test_scan_squad_no_issues(self, tmp_path):
-        """Squad with valid references passes"""
-        squad_dir = tmp_path / "valid-squad"
-        squad_dir.mkdir()
-
-        agents_dir = squad_dir / "agents"
-        agents_dir.mkdir()
-        (agents_dir / "agent.md").write_text("# Agent\nNo references here.")
-
-        tasks_dir = squad_dir / "tasks"
-        tasks_dir.mkdir()
-        (tasks_dir / "task.md").write_text("# Task\nNo references here.")
-
-        result = scan_squad(str(squad_dir))
-
-        assert result["status"] == "PASS"
-        assert result["total_issues"] == 0
-
-    def test_scan_squad_with_issues(self, tmp_path):
-        """Squad with broken references fails"""
-        squad_dir = tmp_path / "broken-squad"
-        squad_dir.mkdir()
-
-        agents_dir = squad_dir / "agents"
-        agents_dir.mkdir()
-        (agents_dir / "agent.md").write_text("# Agent\nUses tasks/missing.md")
-
-        (squad_dir / "tasks").mkdir()
-
-        result = scan_squad(str(squad_dir))
-
-        assert result["status"] == "FAIL"
-        assert result["total_issues"] > 0
-
-    def test_scan_squad_by_directory(self, sample_squad):
-        """Results include breakdown by directory"""
-        result = scan_squad(str(sample_squad))
-
-        assert "by_directory" in result
-        # Should have entries for scanned directories
-        if result["by_directory"]:
-            for dir_name, stats in result["by_directory"].items():
-                assert "files" in stats
-                assert "references" in stats
-                assert "issues" in stats
-
-
-class TestStrictMode:
-    """Tests for strict mode"""
-
-    def test_strict_mode_checks_external(self, tmp_path):
-        """Strict mode also checks external references"""
-        squad_dir = tmp_path / "test-squad"
-        squad_dir.mkdir()
-
-        agents_dir = squad_dir / "agents"
-        agents_dir.mkdir()
-
-        # Reference in code block (normally external/ignored)
-        agent_content = """# Agent
-
-```yaml
-# Example
-tasks/example.md
-```
-"""
-        (agents_dir / "agent.md").write_text(agent_content)
-        (squad_dir / "tasks").mkdir()
-
-        # Normal mode - example refs ignored
-        result_normal = scan_squad(str(squad_dir), strict=False)
-
-        # Strict mode - example refs checked too
-        result_strict = scan_squad(str(squad_dir), strict=True)
-
-        assert result_strict["strict_mode"] == True
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])