aiox-core 5.0.2 → 5.0.4

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

@@ -0,0 +1,396 @@
+#!/usr/bin/env python3
+"""
+Tests for checklist_validator.py
+Run with: pytest scripts/tests/test_checklist_validator.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 checklist_validator import (
+    VALID_CHECK_TYPES,
+    CHECK_REQUIRED_FIELDS,
+    CheckItem,
+    ChecklistValidation,
+    extract_yaml_blocks,
+    parse_yaml_safely,
+    extract_checks_from_yaml,
+    extract_checklist_metadata,
+    validate_check_item,
+    validate_checklist_file,
+    validate_checklist_directory,
+)
+
+
+class TestExtractYamlBlocks:
+    """Tests for extract_yaml_blocks function"""
+
+    def test_extract_single_block(self):
+        """Single YAML block is extracted"""
+        content = """
+# Checklist
+
+```yaml
+check:
+  id: test-1
+  check: "Test check"
+  type: blocking
+```
+
+More text.
+"""
+        blocks = extract_yaml_blocks(content)
+
+        assert len(blocks) == 1
+        assert "id: test-1" in blocks[0][0]
+
+    def test_extract_multiple_blocks(self):
+        """Multiple YAML blocks are extracted"""
+        content = """
+```yaml
+first: block
+```
+
+```yaml
+second: block
+```
+"""
+        blocks = extract_yaml_blocks(content)
+
+        assert len(blocks) == 2
+        assert "first: block" in blocks[0][0]
+        assert "second: block" in blocks[1][0]
+
+    def test_no_yaml_blocks(self):
+        """No YAML blocks returns empty list"""
+        content = "# Just markdown\n\nNo YAML here."
+
+        blocks = extract_yaml_blocks(content)
+
+        assert len(blocks) == 0
+
+
+class TestParseYamlSafely:
+    """Tests for parse_yaml_safely function"""
+
+    def test_parse_valid_yaml(self):
+        """Valid YAML is parsed"""
+        content = "name: test\nversion: 1.0.0"
+
+        result = parse_yaml_safely(content)
+
+        assert result is not None
+        assert result["name"] == "test"
+
+    def test_parse_invalid_yaml(self):
+        """Invalid YAML returns None"""
+        content = "invalid: yaml: :"
+
+        result = parse_yaml_safely(content)
+
+        # Should handle error gracefully
+        assert result is None or isinstance(result, dict)
+
+
+class TestExtractChecksFromYaml:
+    """Tests for extract_checks_from_yaml function"""
+
+    def test_extract_checks_array(self):
+        """Checks in array are extracted"""
+        yaml_data = {
+            "checks": [
+                {"id": "test-1", "check": "Check 1", "type": "blocking"},
+                {"id": "test-2", "check": "Check 2", "type": "recommended"},
+            ]
+        }
+
+        checks = extract_checks_from_yaml(yaml_data)
+
+        assert len(checks) == 2
+        assert checks[0].id == "test-1"
+        assert checks[1].id == "test-2"
+
+    def test_extract_checks_nested(self):
+        """Checks in nested structure are extracted"""
+        yaml_data = {
+            "file_basics": [
+                {"id": "min-lines", "check": "Min lines", "type": "blocking"},
+            ],
+            "other_checks": [
+                {"id": "other-1", "check": "Other", "type": "warning"},
+            ]
+        }
+
+        checks = extract_checks_from_yaml(yaml_data)
+
+        assert len(checks) == 2
+
+    def test_extract_checks_no_checks(self):
+        """Empty YAML returns empty list"""
+        yaml_data = {"metadata": {"version": "1.0"}}
+
+        checks = extract_checks_from_yaml(yaml_data)
+
+        assert len(checks) == 0
+
+
+class TestExtractChecklistMetadata:
+    """Tests for extract_checklist_metadata function"""
+
+    def test_extract_metadata_from_checklist_key(self):
+        """Metadata extracted from 'checklist' key"""
+        yaml_data = {
+            "checklist": {
+                "id": "test-checklist",
+                "version": "1.0.0",
+                "purpose": "Test purpose"
+            }
+        }
+
+        metadata = extract_checklist_metadata(yaml_data)
+
+        assert metadata["id"] == "test-checklist"
+        assert metadata["version"] == "1.0.0"
+        assert metadata["purpose"] == "Test purpose"
+
+    def test_extract_metadata_from_top_level(self):
+        """Metadata extracted from top-level keys"""
+        yaml_data = {
+            "id": "test-checklist",
+            "version": "2.0.0",
+        }
+
+        metadata = extract_checklist_metadata(yaml_data)
+
+        assert metadata["id"] == "test-checklist"
+
+    def test_extract_metadata_empty(self):
+        """Empty data returns empty metadata"""
+        yaml_data = {"checks": []}
+
+        metadata = extract_checklist_metadata(yaml_data)
+
+        assert metadata == {} or "id" not in metadata
+
+
+class TestValidateCheckItem:
+    """Tests for validate_check_item function"""
+
+    def test_validate_valid_check(self):
+        """Valid check has no issues"""
+        check = CheckItem(
+            id="test-1",
+            check="Test check description",
+            type="blocking",
+            validation="test command"
+        )
+
+        issues, warnings = validate_check_item(check)
+
+        assert len(issues) == 0
+
+    def test_validate_missing_id(self):
+        """Missing ID produces issue"""
+        check = CheckItem(
+            id="",
+            check="Test check",
+            type="blocking"
+        )
+
+        issues, warnings = validate_check_item(check)
+
+        id_issues = [i for i in issues if "CKL-CHK-001" in i["code"]]
+        assert len(id_issues) == 1
+
+    def test_validate_missing_check_description(self):
+        """Missing check description produces issue"""
+        check = CheckItem(
+            id="test-1",
+            check="",
+            type="blocking"
+        )
+
+        issues, warnings = validate_check_item(check)
+
+        check_issues = [i for i in issues if "CKL-CHK-002" in i["code"]]
+        assert len(check_issues) == 1
+
+    def test_validate_invalid_type(self):
+        """Non-standard type produces warning"""
+        check = CheckItem(
+            id="test-1",
+            check="Test check",
+            type="invalid-type"
+        )
+
+        issues, warnings = validate_check_item(check)
+
+        type_warnings = [w for w in warnings if "CKL-CHK-003" in w["code"]]
+        assert len(type_warnings) == 1
+
+    def test_validate_blocking_without_validation(self):
+        """Blocking check without validation produces warning"""
+        check = CheckItem(
+            id="test-1",
+            check="Test check",
+            type="blocking",
+            validation=None
+        )
+
+        issues, warnings = validate_check_item(check)
+
+        val_warnings = [w for w in warnings if "CKL-CHK-004" in w["code"]]
+        assert len(val_warnings) == 1
+
+
+class TestValidateChecklistFile:
+    """Tests for validate_checklist_file function"""
+
+    def test_validate_nonexistent_file(self, tmp_path):
+        """Nonexistent file returns invalid"""
+        result = validate_checklist_file(tmp_path / "nonexistent.md")
+
+        assert result.valid == False
+        assert len(result.issues) > 0
+
+    def test_validate_valid_checklist(self, tmp_path):
+        """Valid checklist passes"""
+        checklist_content = """# Test Checklist
+
+```yaml
+checklist:
+  id: test-checklist
+  version: 1.0.0
+  purpose: Test validation
+```
+
+## Checks
+
+```yaml
+file_checks:
+  - id: check-1
+    check: "Check 1 description"
+    type: blocking
+    validation: "test command"
+
+  - id: check-2
+    check: "Check 2 description"
+    type: recommended
+```
+"""
+        checklist_file = tmp_path / "test-checklist.md"
+        checklist_file.write_text(checklist_content)
+
+        result = validate_checklist_file(checklist_file)
+
+        assert result.valid == True
+        assert result.has_metadata == True
+        assert result.check_count == 2
+        assert result.checks_by_type.get("blocking") == 1
+        assert result.checks_by_type.get("recommended") == 1
+
+    def test_validate_checklist_no_yaml(self, tmp_path):
+        """Checklist without YAML produces warning"""
+        content = "# Checklist\n\nNo YAML here."
+        checklist_file = tmp_path / "no-yaml.md"
+        checklist_file.write_text(content)
+
+        result = validate_checklist_file(checklist_file)
+
+        # Should still be "valid" but with warnings
+        yaml_warnings = [w for w in result.warnings if "YAML" in w["message"]]
+        assert len(yaml_warnings) > 0
+
+    def test_validate_duplicate_ids(self, tmp_path):
+        """Duplicate IDs produce issues"""
+        content = """# Checklist
+
+```yaml
+checks:
+  - id: same-id
+    check: "First"
+    type: blocking
+  - id: same-id
+    check: "Second"
+    type: blocking
+```
+"""
+        checklist_file = tmp_path / "dupe.md"
+        checklist_file.write_text(content)
+
+        result = validate_checklist_file(checklist_file)
+
+        dup_issues = [i for i in result.issues if "DUP" in i["code"]]
+        assert len(dup_issues) == 1
+
+
+class TestValidateChecklistDirectory:
+    """Tests for validate_checklist_directory function"""
+
+    def test_validate_empty_directory(self, tmp_path):
+        """Empty directory returns zero files"""
+        result = validate_checklist_directory(tmp_path)
+
+        assert result["total_files"] == 0
+        assert result["valid_files"] == 0
+
+    def test_validate_directory_with_checklists(self, tmp_path):
+        """Directory with checklists is validated"""
+        # Create two checklists
+        (tmp_path / "checklist-1.md").write_text("""# Checklist 1
+
+```yaml
+checks:
+  - id: c1
+    check: "Check 1"
+    type: blocking
+```
+""")
+
+        (tmp_path / "checklist-2.md").write_text("""# Checklist 2
+
+```yaml
+checks:
+  - id: c2
+    check: "Check 2"
+    type: recommended
+```
+""")
+
+        result = validate_checklist_directory(tmp_path)
+
+        assert result["total_files"] == 2
+        assert result["total_checks"] == 2
+        assert result["checks_by_type"]["blocking"] == 1
+        assert result["checks_by_type"]["recommended"] == 1
+
+    def test_validate_directory_nonexistent(self, tmp_path):
+        """Nonexistent directory returns error"""
+        result = validate_checklist_directory(tmp_path / "nonexistent")
+
+        assert "error" in result
+
+
+class TestValidCheckTypes:
+    """Tests for valid check types constant"""
+
+    def test_blocking_is_valid(self):
+        """'blocking' is a valid type"""
+        assert "blocking" in VALID_CHECK_TYPES
+
+    def test_recommended_is_valid(self):
+        """'recommended' is a valid type"""
+        assert "recommended" in VALID_CHECK_TYPES
+
+    def test_warning_is_valid(self):
+        """'warning' is a valid type"""
+        assert "warning" in VALID_CHECK_TYPES
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

package/pro/squads/squad-creator-pro/scripts/tests/test_clone_review.sh

@@ -0,0 +1,239 @@
+#!/bin/bash
+# Tests for clone-review.sh
+# Run: bash squads/squad-creator-pro/scripts/tests/test_clone_review.sh
+
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SCRIPT="$SCRIPT_DIR/../clone-review.sh"
+PASS=0
+FAIL=0
+TOTAL=0
+
+assert_eq() {
+    local test_name="$1" expected="$2" actual="$3"
+    TOTAL=$((TOTAL + 1))
+    if [[ "$expected" == "$actual" ]]; then
+        PASS=$((PASS + 1))
+    else
+        FAIL=$((FAIL + 1))
+        echo "  FAIL: $test_name (expected '$expected', got '$actual')"
+    fi
+}
+
+assert_contains() {
+    local test_name="$1" pattern="$2" text="$3"
+    TOTAL=$((TOTAL + 1))
+    if echo "$text" | grep -qE "$pattern"; then
+        PASS=$((PASS + 1))
+    else
+        FAIL=$((FAIL + 1))
+        echo "  FAIL: $test_name (pattern '$pattern' not found)"
+    fi
+}
+
+assert_exit() {
+    local test_name="$1" expected="$2" actual="$3"
+    TOTAL=$((TOTAL + 1))
+    if [[ "$expected" == "$actual" ]]; then
+        PASS=$((PASS + 1))
+    else
+        FAIL=$((FAIL + 1))
+        echo "  FAIL: $test_name (expected exit $expected, got $actual)"
+    fi
+}
+
+echo "=== test_clone_review.sh ==="
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+
+# Fixture: well-structured clone
+cat > "$TMP/good-clone.md" << 'FIXTURE'
+# Good Clone
+
+## Workflow
+
+### Step 1: Initialize
+Execute the setup process.
+
+### Step 2: Analyze
+Generate the analysis report.
+
+### Step 3: Validate
+Check and verify all results.
+
+output: Final report
+
+## Framework
+
+framework: Decision Pipeline
+rules:
+  - SE: input is valid
+    ENTAO: process it
+  - SE: input is invalid
+    action: reject
+
+if: condition A
+then: do X
+else: do Y
+otherwise: fallback
+
+## Examples
+
+examples:
+  - input: "Test query"
+    output: "Test response"
+    e.g. this shows the pattern
+
+good example: structured query
+bad example: unstructured input
+edge case: empty input
+
+[SOURCE: Real interaction]
+
+## Voice DNA
+
+voice_dna:
+  vocabulary:
+    always_use:
+      - validate
+      - execute
+    never_use:
+      - maybe
+
+signature_phrases:
+  - "Let's be direct"
+  - "No shortcuts"
+  - "Quality first"
+
+catchphrases:
+  - "Here's the deal"
+
+## Thinking DNA
+
+thinking_dna:
+  primary_framework: Decision Pipeline
+  mental_models:
+    - First Principles
+
+framework: Strategic Analysis
+framework: Risk Assessment
+
+## Immune System
+
+veto: Never skip validation
+never: Compromise quality
+objection: Handle with data
+reject: Low-quality input
+
+## Stages
+
+stages:
+  - stage_1: Research
+    trigger: New request
+    behavior: Gather data
+    action: Collect sources
+    transition: Move to analysis
+  - stage_2: Analysis
+    trigger: Data ready
+    behavior: Analyze patterns
+FIXTURE
+
+# Fixture: minimal clone
+cat > "$TMP/minimal-clone.md" << 'FIXTURE'
+# Minimal Clone
+
+This is a simple placeholder.
+Not much here.
+FIXTURE
+
+# Fixture: sources directory
+SOURCES="$TMP/sources"
+mkdir -p "$SOURCES"
+echo "tier: ouro" > "$SOURCES/source1.md"
+echo "tier: ouro" > "$SOURCES/source2.md"
+echo "tier: bronze" > "$SOURCES/source3.md"
+
+# --- Test 1: No args ---
+echo "  Test: no args"
+output=$(bash "$SCRIPT" 2>&1)
+exit_code=$?
+assert_exit "no_args" "1" "$exit_code"
+assert_contains "no_args_usage" "Usage:" "$output"
+
+# --- Test 2: Missing file ---
+echo "  Test: missing file"
+output=$(bash "$SCRIPT" "$TMP/nonexistent.md" 2>&1)
+exit_code=$?
+assert_exit "missing_file" "1" "$exit_code"
+
+# --- Test 3: Good clone produces report ---
+echo "  Test: good clone report"
+output=$(bash "$SCRIPT" "$TMP/good-clone.md" 2>&1)
+exit_code=$?
+assert_exit "good_exit" "0" "$exit_code"
+assert_contains "has_header" "Clone Review Report" "$output"
+
+# --- Test 4: Trinity sections present ---
+echo "  Test: trinity"
+output=$(bash "$SCRIPT" "$TMP/good-clone.md" 2>&1)
+assert_contains "has_trinity" "trinity:" "$output"
+assert_contains "has_playbook" "playbook:" "$output"
+assert_contains "has_framework" "framework:" "$output"
+assert_contains "has_swipe" "swipe_file:" "$output"
+
+# --- Test 5: Trinity scores for good clone ---
+echo "  Test: trinity scores"
+trinity_pct=$(echo "$output" | grep "trinity_percentage:" | head -1 | sed 's/[^0-9]//g')
+TOTAL=$((TOTAL + 1))
+if [[ -n "$trinity_pct" && "$trinity_pct" -ge 50 ]]; then
+    PASS=$((PASS + 1))
+else
+    FAIL=$((FAIL + 1))
+    echo "  FAIL: trinity_score (expected >=50%, got ${trinity_pct}%)"
+fi
+
+# --- Test 6: Stages section ---
+echo "  Test: stages"
+assert_contains "has_stages" "stages:" "$output"
+assert_contains "stages_true" "has_stages: true" "$output"
+
+# --- Test 7: Quick fidelity ---
+echo "  Test: quick fidelity"
+assert_contains "has_quick_fidelity" "quick_fidelity:" "$output"
+
+# --- Test 8: Overall verdict ---
+echo "  Test: verdict"
+assert_contains "has_verdict" "verdict:" "$output"
+
+# --- Test 9: With sources directory ---
+echo "  Test: with sources"
+output=$(bash "$SCRIPT" "$TMP/good-clone.md" "$SOURCES" 2>&1)
+exit_code=$?
+assert_exit "with_sources" "0" "$exit_code"
+assert_contains "has_source_quality" "source_quality:" "$output"
+assert_contains "has_total_sources" "total_sources:" "$output"
+total_src=$(echo "$output" | grep "total_sources:" | head -1 | grep -oE '[0-9]+')
+assert_eq "source_count" "3" "$total_src"
+
+# --- Test 10: Without sources directory ---
+echo "  Test: without sources"
+output=$(bash "$SCRIPT" "$TMP/good-clone.md" 2>&1)
+assert_contains "no_sources_note" "no_sources_dir" "$output"
+
+# --- Test 11: Minimal clone scores low ---
+echo "  Test: minimal clone"
+output=$(bash "$SCRIPT" "$TMP/minimal-clone.md" 2>&1)
+verdict=$(echo "$output" | grep "verdict:" | tail -1 | sed 's/.*: "//' | sed 's/".*//')
+assert_eq "minimal_verdict" "REBUILD" "$verdict"
+
+# --- Test 12: Determinism ---
+echo "  Test: determinism"
+out1=$(bash "$SCRIPT" "$TMP/good-clone.md" 2>&1 | grep "verdict:" | tail -1)
+out2=$(bash "$SCRIPT" "$TMP/good-clone.md" 2>&1 | grep "verdict:" | tail -1)
+assert_eq "deterministic" "$out1" "$out2"
+
+echo ""
+echo "=== RESULTS: $PASS/$TOTAL passed, $FAIL failed ==="
+[[ $FAIL -eq 0 ]] && exit 0 || exit 1