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_checklist_validator.py DELETED Viewed

@@ -1,396 +0,0 @@
-#!/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 DELETED Viewed

@@ -1,239 +0,0 @@
-#!/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