npm - aiox-core - Versions diffs - 5.0.3 → 5.0.5 - Mend

aiox-core 5.0.3 → 5.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (652) hide show

package/pro/squads/squad-creator-pro/scripts/tests/test_quality_gate.py DELETED Viewed

@@ -1,280 +0,0 @@
-#!/usr/bin/env python3
-"""
-Tests for quality_gate.py
-Run with: pytest scripts/tests/ -v
-"""
-import os
-import sys
-import json
-import tempfile
-import pytest
-from pathlib import Path
-# Add parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent.parent))
-from quality_gate import (
-    count_lines,
-    count_yaml_items,
-    check_agent_quality,
-    check_task_quality,
-    check_squad_quality,
-    scan_squad,
-    THRESHOLDS
-)
-class TestCountLines:
-    """Tests for count_lines function"""
-    def test_count_lines_simple_file(self, tmp_path):
-        """Test counting lines in a simple file"""
-        test_file = tmp_path / "test.txt"
-        test_file.write_text("line1\nline2\nline3\n")
-        assert count_lines(str(test_file)) == 4
-    def test_count_lines_empty_file(self, tmp_path):
-        """Test counting lines in empty file"""
-        test_file = tmp_path / "empty.txt"
-        test_file.write_text("")
-        assert count_lines(str(test_file)) == 0
-    def test_count_lines_nonexistent_file(self):
-        """Test counting lines in nonexistent file"""
-        assert count_lines("/nonexistent/file.txt") == 0
-    def test_count_lines_large_file(self, tmp_path):
-        """Test counting lines in larger file"""
-        test_file = tmp_path / "large.txt"
-        test_file.write_text("\n".join([f"line {i}" for i in range(500)]))
-        assert count_lines(str(test_file)) == 500
-class TestCheckAgentQuality:
-    """Tests for check_agent_quality function"""
-    def test_check_agent_quality_minimal(self, tmp_path):
-        """Test agent quality check with minimal file"""
-        agent_file = tmp_path / "minimal.md"
-        agent_file.write_text("# Agent\n\nMinimal content\n")
-        result = check_agent_quality(str(agent_file))
-        assert result["file"] == "minimal.md"
-        assert result["type"] == "agent"
-        assert result["metrics"]["lines"] < THRESHOLDS["agent"]["min_lines"]
-        assert len(result["issues"]) > 0  # Should have line count warning
-    def test_check_agent_quality_with_yaml(self, tmp_path):
-        """Test agent quality check with YAML content"""
-        agent_content = '''# Test Agent
-```yaml
-agent:
-  name: Test Agent
-  id: test-agent
-voice_dna:
-  vocabulary:
-    always_use:
-      - term1
-      - term2
-      - term3
-      - term4
-      - term5
-    never_use:
-      - bad1
-      - bad2
-      - bad3
-output_examples:
-  - input: test1
-    output: result1
-  - input: test2
-    output: result2
-  - input: test3
-    output: result3
-objection_algorithms:
-  - objection: obj1
-    response: resp1
-  - objection: obj2
-    response: resp2
-  - objection: obj3
-    response: resp3
-```
-'''
-        # Add enough lines to pass threshold
-        agent_content += "\n" * 300
-        agent_file = tmp_path / "test-agent.md"
-        agent_file.write_text(agent_content)
-        result = check_agent_quality(str(agent_file))
-        assert result["metrics"].get("vocabulary_always", 0) == 5
-        assert result["metrics"].get("vocabulary_never", 0) == 3
-        assert result["metrics"].get("output_examples", 0) == 3
-        assert result["metrics"].get("objection_algorithms", 0) == 3
-class TestCheckTaskQuality:
-    """Tests for check_task_quality function"""
-    def test_check_task_quality_minimal(self, tmp_path):
-        """Test task quality check with minimal file"""
-        task_file = tmp_path / "minimal-task.md"
-        task_file.write_text("# Task\n\nDo something\n")
-        result = check_task_quality(str(task_file))
-        assert result["file"] == "minimal-task.md"
-        assert result["type"] == "task"
-        assert result["metrics"]["lines"] < THRESHOLDS["task"]["min_lines"]
-    def test_check_task_quality_sufficient(self, tmp_path):
-        """Test task quality check with sufficient content"""
-        task_content = "# Task\n\n" + "\n".join([f"Step {i}" for i in range(150)])
-        task_file = tmp_path / "good-task.md"
-        task_file.write_text(task_content)
-        result = check_task_quality(str(task_file))
-        assert result["metrics"]["lines"] >= THRESHOLDS["task"]["min_lines"]
-        assert len([i for i in result["issues"] if "lines" in i.get("metric", "")]) == 0
-class TestCheckSquadQuality:
-    """Tests for check_squad_quality function"""
-    def test_check_squad_quality_complete(self, tmp_path):
-        """Test squad quality check with complete structure"""
-        # Create squad structure
-        squad_dir = tmp_path / "test-squad"
-        squad_dir.mkdir()
-        # Required files
-        (squad_dir / "config.yaml").write_text("name: test-squad\n")
-        (squad_dir / "README.md").write_text("# Test Squad\n")
-        (squad_dir / "CHANGELOG.md").write_text("# Changelog\n")
-        # Required directories with content
-        agents_dir = squad_dir / "agents"
-        agents_dir.mkdir()
-        (agents_dir / "test-agent.md").write_text("# Agent\n" * 100)
-        tasks_dir = squad_dir / "tasks"
-        tasks_dir.mkdir()
-        (tasks_dir / "test-task.md").write_text("# Task\n" * 50)
-        result = check_squad_quality(str(squad_dir))
-        assert result["squad_name"] == "test-squad"
-        assert result["passed"] == True
-        assert result["metrics"]["has_config_yaml"] == True
-        assert result["metrics"]["has_README_md"] == True
-        assert result["metrics"]["agent_count"] == 1
-        assert result["metrics"]["task_count"] == 1
-    def test_check_squad_quality_missing_files(self, tmp_path):
-        """Test squad quality check with missing required files"""
-        squad_dir = tmp_path / "incomplete-squad"
-        squad_dir.mkdir()
-        result = check_squad_quality(str(squad_dir))
-        assert result["passed"] == False
-        assert any(i["code"] == "QG-SQD-REQFILE" for i in result["issues"])
-    def test_check_squad_quality_missing_dirs(self, tmp_path):
-        """Test squad quality check with missing directories"""
-        squad_dir = tmp_path / "no-dirs-squad"
-        squad_dir.mkdir()
-        (squad_dir / "config.yaml").write_text("name: test\n")
-        (squad_dir / "README.md").write_text("# Test\n")
-        result = check_squad_quality(str(squad_dir))
-        assert result["passed"] == False
-        assert any(i["code"] == "QG-SQD-REQDIR" for i in result["issues"])
-class TestScanSquad:
-    """Tests for scan_squad function"""
-    def test_scan_squad_complete(self, tmp_path):
-        """Test full squad scan"""
-        # Create complete squad structure
-        squad_dir = tmp_path / "full-squad"
-        squad_dir.mkdir()
-        (squad_dir / "config.yaml").write_text("name: full-squad\nversion: 1.0.0\n")
-        (squad_dir / "README.md").write_text("# Full Squad\n\nDescription here.\n")
-        agents_dir = squad_dir / "agents"
-        agents_dir.mkdir()
-        (agents_dir / "main-agent.md").write_text("# Agent\n" * 150)
-        tasks_dir = squad_dir / "tasks"
-        tasks_dir.mkdir()
-        (tasks_dir / "main-task.md").write_text("# Task\n" * 60)
-        results = scan_squad(str(squad_dir))
-        assert results["exists"] == True
-        assert results["squad_name"] == "full-squad"
-        assert len(results["agent_checks"]) == 1
-        assert len(results["task_checks"]) == 1
-    def test_scan_squad_nonexistent(self):
-        """Test scanning nonexistent squad"""
-        results = scan_squad("/nonexistent/squad/path")
-        assert results["exists"] == False
-        assert "error" in results
-    def test_scan_squad_strict_mode(self, tmp_path):
-        """Test strict mode in squad scan"""
-        squad_dir = tmp_path / "strict-squad"
-        squad_dir.mkdir()
-        (squad_dir / "config.yaml").write_text("name: test\n")
-        (squad_dir / "README.md").write_text("# Test\n")
-        agents_dir = squad_dir / "agents"
-        agents_dir.mkdir()
-        (agents_dir / "agent.md").write_text("# Small agent\n")
-        tasks_dir = squad_dir / "tasks"
-        tasks_dir.mkdir()
-        (tasks_dir / "task.md").write_text("# Task\n")
-        results = scan_squad(str(squad_dir), strict=True)
-        assert results["strict_mode"] == True
-class TestThresholds:
-    """Tests for threshold constants"""
-    def test_agent_thresholds_exist(self):
-        """Test that agent thresholds are defined"""
-        assert "agent" in THRESHOLDS
-        assert THRESHOLDS["agent"]["min_lines"] == 300
-        assert THRESHOLDS["agent"]["min_output_examples"] == 3
-    def test_task_thresholds_exist(self):
-        """Test that task thresholds are defined"""
-        assert "task" in THRESHOLDS
-        assert THRESHOLDS["task"]["min_lines"] == 100
-    def test_squad_thresholds_exist(self):
-        """Test that squad thresholds are defined"""
-        assert "squad" in THRESHOLDS
-        assert "config.yaml" in THRESHOLDS["squad"]["required_files"]
-        assert "README.md" in THRESHOLDS["squad"]["required_files"]
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

package/pro/squads/squad-creator-pro/scripts/tests/test_refresh_registry.py DELETED Viewed

@@ -1,338 +0,0 @@
-#!/usr/bin/env python3
-"""
-Tests for refresh-registry.py
-Run with: pytest scripts/tests/test_refresh_registry.py -v
-"""
-import os
-import sys
-import pytest
-from pathlib import Path
-from datetime import datetime
-# Add parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent.parent))
-# Import using underscore version of module name
-import importlib.util
-spec = importlib.util.spec_from_file_location(
-    "refresh_registry",
-    Path(__file__).parent.parent / "refresh-registry.py"
-)
-refresh_registry = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(refresh_registry)
-count_files = refresh_registry.count_files
-read_config_yaml = refresh_registry.read_config_yaml
-list_agents = refresh_registry.list_agents
-scan_squad = refresh_registry.scan_squad
-scan_all_squads = refresh_registry.scan_all_squads
-format_for_registry = refresh_registry.format_for_registry
-class TestCountFiles:
-    """Tests for count_files function"""
-    def test_count_files_empty_dir(self, tmp_path):
-        """Empty directory returns 0"""
-        empty_dir = tmp_path / "empty"
-        empty_dir.mkdir()
-        result = count_files(empty_dir, ["*.md"])
-        assert result == 0
-    def test_count_files_with_matches(self, tmp_path):
-        """Files matching pattern are counted"""
-        test_dir = tmp_path / "test"
-        test_dir.mkdir()
-        (test_dir / "file1.md").write_text("# F1")
-        (test_dir / "file2.md").write_text("# F2")
-        (test_dir / "file3.txt").write_text("TXT")
-        result = count_files(test_dir, ["*.md"])
-        assert result == 2
-    def test_count_files_multiple_patterns(self, tmp_path):
-        """Multiple patterns work correctly"""
-        test_dir = tmp_path / "test"
-        test_dir.mkdir()
-        (test_dir / "file.md").write_text("MD")
-        (test_dir / "file.yaml").write_text("YAML")
-        (test_dir / "file.txt").write_text("TXT")
-        result = count_files(test_dir, ["*.md", "*.yaml"])
-        assert result == 2
-    def test_count_files_nonexistent(self, tmp_path):
-        """Nonexistent directory is handled"""
-        # Function should handle this gracefully
-        result = count_files(tmp_path / "nonexistent", ["*.md"])
-        assert result == 0
-class TestReadConfigYaml:
-    """Tests for read_config_yaml function"""
-    def test_read_config_yaml_exists(self, tmp_path):
-        """Config is parsed when exists"""
-        squad_dir = tmp_path / "test-squad"
-        squad_dir.mkdir()
-        (squad_dir / "config.yaml").write_text("""
-name: test-squad
-version: 1.0.0
-description: Test description
-slashPrefix: testSquad
-short-title: Test
-""")
-        result = read_config_yaml(squad_dir)
-        assert result is not None
-        assert result["name"] == "test-squad"
-        assert result["version"] == "1.0.0"
-    def test_read_config_yaml_not_exists(self, tmp_path):
-        """Returns None when config doesn't exist"""
-        squad_dir = tmp_path / "test-squad"
-        squad_dir.mkdir()
-        result = read_config_yaml(squad_dir)
-        assert result is None
-class TestListAgents:
-    """Tests for list_agents function"""
-    def test_list_agents_with_agents(self, tmp_path):
-        """Agents are listed correctly"""
-        squad_dir = tmp_path / "test-squad"
-        squad_dir.mkdir()
-        agents_dir = squad_dir / "agents"
-        agents_dir.mkdir()
-        (agents_dir / "agent-one.md").write_text("# Agent 1")
-        (agents_dir / "agent-two.md").write_text("# Agent 2")
-        result = list_agents(squad_dir)
-        assert len(result) == 2
-        assert "agent-one" in result
-        assert "agent-two" in result
-    def test_list_agents_excludes_readme(self, tmp_path):
-        """README.md is excluded from agent list"""
-        squad_dir = tmp_path / "test-squad"
-        squad_dir.mkdir()
-        agents_dir = squad_dir / "agents"
-        agents_dir.mkdir()
-        (agents_dir / "real-agent.md").write_text("# Agent")
-        (agents_dir / "README.md").write_text("# README")
-        (agents_dir / "template.md").write_text("# Template")
-        result = list_agents(squad_dir)
-        assert len(result) == 1
-        assert "real-agent" in result
-        assert "README" not in result
-        assert "template" not in result
-    def test_list_agents_no_dir(self, tmp_path):
-        """No agents directory returns empty list"""
-        squad_dir = tmp_path / "test-squad"
-        squad_dir.mkdir()
-        result = list_agents(squad_dir)
-        assert result == []
-class TestScanSquad:
-    """Tests for scan_squad function"""
-    def test_scan_squad_complete(self, tmp_path):
-        """Complete squad is scanned correctly"""
-        squad_dir = tmp_path / "test-squad"
-        squad_dir.mkdir()
-        # Config
-        (squad_dir / "config.yaml").write_text("""
-name: test-squad
-version: 2.0.0
-description: A test squad
-slashPrefix: testSquad
-short-title: Test
-""")
-        # Agents
-        agents_dir = squad_dir / "agents"
-        agents_dir.mkdir()
-        (agents_dir / "agent-one.md").write_text("# A1")
-        (agents_dir / "agent-two.md").write_text("# A2")
-        # Tasks
-        tasks_dir = squad_dir / "tasks"
-        tasks_dir.mkdir()
-        (tasks_dir / "task.md").write_text("# Task")
-        # README
-        (squad_dir / "README.md").write_text("# README")
-        (squad_dir / "CHANGELOG.md").write_text("# Changelog")
-        result = scan_squad(squad_dir)
-        assert result["name"] == "test-squad"
-        assert result["has_config"] == True
-        assert result["config"]["version"] == "2.0.0"
-        assert result["counts"]["agents"] == 2
-        assert result["counts"]["tasks"] == 1
-        assert result["has_readme"] == True
-        assert result["has_changelog"] == True
-        assert len(result["agent_names"]) == 2
-    def test_scan_squad_minimal(self, tmp_path):
-        """Minimal squad still produces results"""
-        squad_dir = tmp_path / "minimal-squad"
-        squad_dir.mkdir()
-        result = scan_squad(squad_dir)
-        assert result["name"] == "minimal-squad"
-        assert result["has_config"] == False
-        assert result["counts"]["agents"] == 0
-        assert result["total_components"] == 0
-class TestScanAllSquads:
-    """Tests for scan_all_squads function"""
-    def test_scan_all_squads_empty(self, tmp_path):
-        """Empty squads directory returns empty results"""
-        squads_dir = tmp_path / "squads"
-        squads_dir.mkdir()
-        result = scan_all_squads(squads_dir)
-        assert result["metadata"]["total_squads"] == 0
-        assert len(result["squads"]) == 0
-    def test_scan_all_squads_multiple(self, tmp_path):
-        """Multiple squads are scanned"""
-        squads_dir = tmp_path / "squads"
-        squads_dir.mkdir()
-        # Squad 1
-        squad1 = squads_dir / "squad-one"
-        squad1.mkdir()
-        (squad1 / "config.yaml").write_text("name: squad-one\nversion: 1.0.0")
-        (squad1 / "agents").mkdir()
-        (squad1 / "agents" / "agent.md").write_text("# A")
-        # Squad 2
-        squad2 = squads_dir / "squad-two"
-        squad2.mkdir()
-        (squad2 / "config.yaml").write_text("name: squad-two\nversion: 1.0.0")
-        (squad2 / "agents").mkdir()
-        (squad2 / "agents" / "agent.md").write_text("# A")
-        result = scan_all_squads(squads_dir)
-        assert result["metadata"]["total_squads"] == 2
-        assert "squad-one" in result["squads"]
-        assert "squad-two" in result["squads"]
-        assert result["summary"]["total_agents"] == 2
-    def test_scan_all_squads_skips_invalid(self, tmp_path):
-        """Invalid directories are skipped"""
-        squads_dir = tmp_path / "squads"
-        squads_dir.mkdir()
-        # Valid squad
-        valid = squads_dir / "valid-squad"
-        valid.mkdir()
-        (valid / "config.yaml").write_text("name: valid-squad")
-        # Invalid - no config or agents
-        invalid = squads_dir / "not-a-squad"
-        invalid.mkdir()
-        (invalid / "random.txt").write_text("random")
-        # Hidden directory
-        hidden = squads_dir / ".hidden"
-        hidden.mkdir()
-        result = scan_all_squads(squads_dir)
-        assert result["metadata"]["total_squads"] == 1
-        assert "valid-squad" in result["squads"]
-        assert "not-a-squad" not in result["squads"]
-        assert ".hidden" not in result["squads"]
-class TestFormatForRegistry:
-    """Tests for format_for_registry function"""
-    def test_format_for_registry_structure(self, tmp_path):
-        """Registry format has correct structure"""
-        squads_dir = tmp_path / "squads"
-        squads_dir.mkdir()
-        squad = squads_dir / "test-squad"
-        squad.mkdir()
-        (squad / "config.yaml").write_text("""
-name: test-squad
-version: 1.0.0
-description: Test
-slashPrefix: testSquad
-""")
-        (squad / "agents").mkdir()
-        scan_results = scan_all_squads(squads_dir)
-        registry = format_for_registry(scan_results)
-        assert "metadata" in registry
-        assert "squads" in registry
-        assert "summary" in registry
-        assert registry["metadata"]["maintainer"] == "squad-creator"
-        assert registry["metadata"]["generated_by"] == "scripts/refresh-registry.py"
-    def test_format_for_registry_squad_fields(self, tmp_path):
-        """Each squad in registry has required fields"""
-        squads_dir = tmp_path / "squads"
-        squads_dir.mkdir()
-        squad = squads_dir / "test-squad"
-        squad.mkdir()
-        (squad / "config.yaml").write_text("""
-name: test-squad
-version: 2.0.0
-description: Test description
-slashPrefix: testSquad
-""")
-        (squad / "agents").mkdir()
-        scan_results = scan_all_squads(squads_dir)
-        registry = format_for_registry(scan_results)
-        squad_data = registry["squads"]["test-squad"]
-        assert "path" in squad_data
-        assert "version" in squad_data
-        assert "description" in squad_data
-        assert "slashPrefix" in squad_data
-        assert "counts" in squad_data
-        assert "agent_names" in squad_data
-        assert "domain" in squad_data  # Placeholder for LLM
-        assert "keywords" in squad_data  # Placeholder for LLM
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])