wup 0.2.77__tar.gz → 0.2.79__tar.gz

{wup-0.2.77/wup.egg-info → wup-0.2.79}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wup
-Version: 0.2.77
+Version: 0.2.79
 Summary: WUP (What's Up) - Intelligent file watcher for regression testing in large projects
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0
@@ -23,6 +23,8 @@ Requires-Dist: typer>=0.9.0
 Requires-Dist: pyyaml>=6.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.8; extra == "dev"
 Requires-Dist: goal>=2.1.0; extra == "dev"
 Requires-Dist: costs>=0.1.20; extra == "dev"
 Requires-Dist: pfix>=0.1.60; extra == "dev"
@@ -35,6 +37,9 @@ Requires-Dist: rest2wup; extra == "dev"
 Requires-Dist: httpx>=0.27; extra == "dev"
 Provides-Extra: visual
 Requires-Dist: playwright<2,>=1.40; extra == "visual"
+Provides-Extra: control
+Requires-Dist: dsl2wup>=0.1.0; extra == "control"
+Requires-Dist: uri2wup>=0.1.0; extra == "control"
 Dynamic: license-file
 
 # WUP (What's Up)
@@ -42,17 +47,17 @@ Dynamic: license-file
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.77-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$6.76-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-53.0h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.79-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$7.70-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-54.6h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $6.7608 (106 commits)
-- 👤 **Human dev:** ~$5301 (53.0h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $7.6978 (109 commits)
+- 👤 **Human dev:** ~$5461 (54.6h @ $100/h, 30min dedup)
 
-Generated on 2026-07-17 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+Generated on 2026-07-29 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.77-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.79-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 **WUP (What's Up)** - Intelligent file watcher for regression testing in large projects.
 

{wup-0.2.77 → wup-0.2.79}/README.md

@@ -3,17 +3,17 @@
 
 ## AI Cost Tracking
 
-![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.77-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
-![AI Cost](https://img.shields.io/badge/AI%20Cost-$6.76-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-53.0h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
+![PyPI](https://img.shields.io/badge/pypi-costs-blue) ![Version](https://img.shields.io/badge/version-0.2.79-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![AI Cost](https://img.shields.io/badge/AI%20Cost-$7.70-orange) ![Human Time](https://img.shields.io/badge/Human%20Time-54.6h-blue) ![Model](https://img.shields.io/badge/Model-openrouter%2Fqwen%2Fqwen3--coder--next-lightgrey)
 
-- 🤖 **LLM usage:** $6.7608 (106 commits)
-- 👤 **Human dev:** ~$5301 (53.0h @ $100/h, 30min dedup)
+- 🤖 **LLM usage:** $7.6978 (109 commits)
+- 👤 **Human dev:** ~$5461 (54.6h @ $100/h, 30min dedup)
 
-Generated on 2026-07-17 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
+Generated on 2026-07-29 using [openrouter/qwen/qwen3-coder-next](https://openrouter.ai/qwen/qwen3-coder-next)
 
 ---
 
-![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.77-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
+![PyPI](https://img.shields.io/badge/pypi-wup-blue) ![Version](https://img.shields.io/badge/version-0.2.79-blue) ![Python](https://img.shields.io/badge/python-3.9+-blue) ![License](https://img.shields.io/badge/license-Apache--2.0-green)
 
 **WUP (What's Up)** - Intelligent file watcher for regression testing in large projects.
 

{wup-0.2.77 → wup-0.2.79}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wup"
-version = "0.2.77"
+version = "0.2.79"
 description = "WUP (What's Up) - Intelligent file watcher for regression testing in large projects"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,6 +32,8 @@ license = "Apache-2.0"
 [project.optional-dependencies]
 dev = [
     "pytest>=7.0.0",
+    "pytest-cov>=5.0",
+    "ruff>=0.8",
     "goal>=2.1.0",
     "costs>=0.1.20",
     "pfix>=0.1.60",
@@ -46,10 +48,16 @@ dev = [
 visual = [
     "playwright>=1.40,<2",
 ]
+control = [
+    "dsl2wup>=0.1.0",
+    "uri2wup>=0.1.0",
+]
 
 [dependency-groups]
 dev = [
     "pytest>=7.0.0",
+    "pytest-cov>=5.0",
+    "ruff>=0.8",
     "goal>=2.1.0",
     "costs>=0.1.20",
     "pfix>=0.1.60",
@@ -87,11 +95,19 @@ testpaths = ["tests", "packages"]
 python_files = ["test_*.py"]
 addopts = "-ra --tb=short"
 
+[tool.ruff.lint]
+# Start with Ruff's stable Pyflakes/pycodestyle correctness baseline. Broader
+# modernization and complexity families can be enabled incrementally.
+select = ["E4", "E7", "E9", "F"]
+
+[tool.ruff.lint.per-file-ignores]
+"packages/dsl2wup/src/dsl2wup/v1/*_pb2.py" = ["E402", "F401"]
+
 [tool.setuptools.packages.find]
 include = ["wup*"]
 
 [project.scripts]
-wup = "wup.cli:app"
+wup = "wup.bootstrap:main"
 
 [project.urls]
 Homepage = "https://github.com/semcod/wup"

{wup-0.2.77 → wup-0.2.79}/tests/test_assistant.py

@@ -1,7 +1,6 @@
 """Unit tests for WupAssistant."""
 import tempfile
 from pathlib import Path
-import pytest
 
 from wup.assistant import WupAssistant
 from wup.models.config import WupConfig, ProjectConfig, ServiceConfig

{wup-0.2.77 → wup-0.2.79}/tests/test_auto_detection.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 from wup.cli_scanner import CLIScanner
 from wup.cli_config_generator import CLIConfigGenerator
-from wup.config import save_config, load_config
+from wup.config import load_config
 
 
 def test_cli_scanner_detects_from_pyproject_toml():

wup-0.2.79/tests/test_bootstrap.py

@@ -0,0 +1,31 @@
+"""Tests for the crash-safe console bootstrap."""
+
+from __future__ import annotations
+
+from unittest.mock import Mock
+
+from wup import bootstrap
+
+
+def test_watchdog_preflight_reports_signal(monkeypatch) -> None:
+    monkeypatch.setattr(
+        bootstrap.subprocess,
+        "run",
+        Mock(return_value=Mock(returncode=-11, stderr="")),
+    )
+
+    ok, detail = bootstrap._watchdog_preflight()
+
+    assert ok is False
+    assert "signal 11" in detail
+
+
+def test_main_stops_before_importing_cli_on_failed_watch_preflight(
+    monkeypatch, capsys
+) -> None:
+    monkeypatch.setattr(bootstrap, "_watchdog_preflight", lambda: (False, "signal 11"))
+
+    code = bootstrap.main(["watch", "."])
+
+    assert code == 70
+    assert "ABI preflight" in capsys.readouterr().err

{wup-0.2.77 → wup-0.2.79}/tests/test_cli_filtering.py

@@ -258,8 +258,8 @@ def test_scenario_matches_type():
         )
         
         # Test type matching
-        assert watcher._scenario_matches_type(cli_scenario, "shell") == True
-        assert watcher._scenario_matches_type(cli_scenario, "web") == False
-        assert watcher._scenario_matches_type(web_scenario, "shell") == False
-        assert watcher._scenario_matches_type(web_scenario, "web") == True
-        assert watcher._scenario_matches_type(cli_scenario, "auto") == True
+        assert watcher._scenario_matches_type(cli_scenario, "shell") is True
+        assert watcher._scenario_matches_type(cli_scenario, "web") is False
+        assert watcher._scenario_matches_type(web_scenario, "shell") is False
+        assert watcher._scenario_matches_type(web_scenario, "web") is True
+        assert watcher._scenario_matches_type(cli_scenario, "auto") is True

{wup-0.2.77 → wup-0.2.79}/tests/test_e2e.py

@@ -7,9 +7,7 @@ import sys
 import tempfile
 import time
 from pathlib import Path
-from typing import List
 
-import pytest
 
 
 def run_wup_command(args, cwd=None, timeout=30, capture_output=True, text=True):
@@ -115,7 +113,7 @@ def get_users():
                 "files": {"app/users/routes.py": ["/users"]}
             }))
             
-            result = run_wup_command(
+            run_wup_command(
                 [sys.executable, "-m", "wup.cli", "status", "--deps", str(deps_file)],
                 cwd=tmpdir,
                 capture_output=True,

{wup-0.2.77 → wup-0.2.79}/tests/test_monitoring_manifest.py

@@ -1,7 +1,6 @@
 import tempfile
 from pathlib import Path
 
-import yaml
 
 from wup.models.config import ProjectConfig, ServiceConfig, TestQLConfig, WupConfig, WatchConfig
 from wup.monitoring_manifest import (

{wup-0.2.77 → wup-0.2.79}/tests/test_multi_project.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
+import os
 from pathlib import Path
 
 from wup.cli import _discover_projects, _resolve_project_paths
-from wup.config import detect_watch_paths, get_default_config
+from wup.config import detect_watch_paths, get_default_config, load_config
 from wup.core import WupWatcher
 from wup.models.config import ProjectConfig, WatchConfig, WupConfig
 from wup.multi import MultiProjectWatcher
@@ -63,6 +64,33 @@ def test_default_config_watches_only_real_dirs(tmp_path: Path) -> None:
     assert cfg.watch.paths == ["services/**"]
 
 
+def test_project_dotenv_is_resolved_without_cross_project_leakage(
+    tmp_path: Path, monkeypatch
+) -> None:
+    monkeypatch.delenv("WUP_BASE_URL", raising=False)
+    monkeypatch.delenv("WUPBRO_ENDPOINT", raising=False)
+    alpha = _make_project(tmp_path, "alpha")
+    beta = _make_project(tmp_path, "beta")
+    (alpha / ".wup.env").write_text(
+        "WUP_BASE_URL=http://alpha.invalid\nWUPBRO_ENDPOINT=http://alpha-web.invalid\n",
+        encoding="utf-8",
+    )
+    (beta / ".wup.env").write_text(
+        "WUP_BASE_URL=http://beta.invalid\nWUPBRO_ENDPOINT=http://beta-web.invalid\n",
+        encoding="utf-8",
+    )
+
+    alpha_cfg = load_config(alpha)
+    beta_cfg = load_config(beta)
+
+    assert alpha_cfg.testql.base_url == "http://alpha.invalid"
+    assert beta_cfg.testql.base_url == "http://beta.invalid"
+    assert alpha_cfg.web.endpoint == "http://alpha-web.invalid"
+    assert beta_cfg.web.endpoint == "http://beta-web.invalid"
+    assert "WUP_BASE_URL" not in os.environ
+    assert "WUPBRO_ENDPOINT" not in os.environ
+
+
 def test_discover_finds_subprojects(tmp_path: Path) -> None:
     _make_project(tmp_path, "alpha")
     _make_project(tmp_path, "beta")

{wup-0.2.77 → wup-0.2.79}/tests/test_service_inference.py

@@ -1,7 +1,6 @@
 """Unit tests for service inference logic."""
 import tempfile
 from pathlib import Path
-from unittest.mock import Mock
 
 from wup.core import WupWatcher
 from wup.models.config import (
@@ -201,7 +200,6 @@ def test_file_change_uses_configured_services_when_inference_fails():
         
         # Mock schedule_quick_test to track which services are tested
         tested_services = []
-        original_schedule = watcher.schedule_quick_test
         watcher.schedule_quick_test = lambda s: tested_services.append(s)
         
         # Trigger file change

{wup-0.2.77 → wup-0.2.79}/tests/test_testql_monitor.py

@@ -11,7 +11,6 @@ from wup.testql_monitor import (
     assign_probe_to_service,
     is_monitoring_probe,
     parse_scenario_probes,
-    parse_service_map_probes,
 )
 from wup.testql_watcher import TestQLWatcher
 
@@ -206,8 +205,6 @@ def test_live_probe_failure_updates_health():
             config=cfg,
         )
 
-        failing = ProbeTarget(url="http://localhost:8100/firmware/api/v1/health")
-
         def fake_probe(self, timeout_s=10.0):
             return False, "HTTP 500 (expected 200)"
 

{wup-0.2.77 → wup-0.2.79}/tests/test_visual_diff_progress.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import io
-import os
 
 from rich.console import Console
 

{wup-0.2.77 → wup-0.2.79}/tests/test_wup.py

@@ -23,6 +23,7 @@ from wup.models.config import (
     ProjectConfig,
     PlanfileConfig,
     VisualDiffConfig,
+    AnomalyDetectionConfig,
 )
 from wup.testql_watcher import TestQLWatcher
 from wup.visual_diff import (
@@ -1313,6 +1314,43 @@ class TestConfigLoader:
             assert loaded_config.project.name == "test-project"
             assert len(loaded_config.services) == 1
             assert loaded_config.services[0].name == "users"
+
+    def test_save_and_load_preserves_every_non_default_section(self):
+        """Fields added to the dataclass schema must not disappear on save."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config = WupConfig(
+                project=ProjectConfig(name="roundtrip", description="all fields"),
+                watch=WatchConfig(
+                    paths=["src/**"],
+                    exclude_patterns=["dist/**"],
+                    file_types=[".py", ".ts"],
+                ),
+                services=[ServiceConfig(
+                    name="worker",
+                    type="shell",
+                    cpu_throttle=0.25,
+                    notify=NotifyConfig(type="http", url="http://notify.invalid"),
+                )],
+                testql=TestQLConfig(quick_smoke_only=True),
+                visual_diff=VisualDiffConfig(run_on_periodic_probe=True),
+                anomaly_detection=AnomalyDetectionConfig(
+                    enabled=False,
+                    methods=["ast"],
+                    strict_mode=True,
+                    watch_paths=["schemas/**"],
+                    severity_threshold="high",
+                ),
+            )
+            config_path = Path(tmpdir) / "wup.yaml"
+
+            save_config(config, config_path)
+            loaded = load_config(Path(tmpdir), config_path)
+
+            assert loaded.watch.file_types == [".py", ".ts"]
+            assert loaded.services[0].type == "shell"
+            assert loaded.testql.quick_smoke_only is True
+            assert loaded.visual_diff.run_on_periodic_probe is True
+            assert loaded.anomaly_detection == config.anomaly_detection
     
     def test_load_config_from_yaml(self):
         """Test loading configuration from YAML file."""

{wup-0.2.77 → wup-0.2.79}/wup/__init__.py

@@ -7,7 +7,7 @@ WUP monitors file changes and runs intelligent regression tests using a 3-layer
 3. Detail Layer: Full tests with blame reports (only on failure)
 """
 
-__version__ = "0.2.77"
+__version__ = "0.2.79"
 __author__ = "Tom Sapletta"
 
 from .config import load_config, save_config, get_default_config

{wup-0.2.77 → wup-0.2.79}/wup/aql.py

@@ -65,36 +65,43 @@ class AQLRule:
 
 # --- path resolution ------------------------------------------------------
 
-def _resolve_path(data: Any, path: str) -> Any:
-    """Resolve a dotted/indexed path (e.g. ``.a.b[0]``) or return ``_MISSING``."""
-    if path in ("", "."):
-        return data
-    # Split ".a.b[0].c" into ['a','b',0,'c'].
+def _path_tokens(path: str) -> List[Any] | None:
+    """Split ``.a.b[0].c`` into ``['a', 'b', 0, 'c']``."""
     tokens: List[Any] = []
     for part in path.lstrip(".").split("."):
         if not part:
             continue
         match = re.match(r"^([^\[\]]*)((?:\[\d+\])*)$", part)
         if not match:
-            return _MISSING
+            return None
         key, indices = match.group(1), match.group(2)
         if key:
             tokens.append(key)
         for idx in re.findall(r"\[(\d+)\]", indices):
             tokens.append(int(idx))
+    return tokens
+
+
+def _path_child(current: Any, token: Any) -> Any:
+    if isinstance(token, int) and isinstance(current, (list, tuple)) and 0 <= token < len(current):
+        return current[token]
+    if isinstance(token, str) and isinstance(current, dict) and token in current:
+        return current[token]
+    return _MISSING
 
+
+def _resolve_path(data: Any, path: str) -> Any:
+    """Resolve a dotted/indexed path (e.g. ``.a.b[0]``) or return ``_MISSING``."""
+    if path in ("", "."):
+        return data
+    tokens = _path_tokens(path)
+    if tokens is None:
+        return _MISSING
     current = data
     for token in tokens:
-        if isinstance(token, int):
-            if isinstance(current, (list, tuple)) and 0 <= token < len(current):
-                current = current[token]
-            else:
-                return _MISSING
-        else:
-            if isinstance(current, dict) and token in current:
-                current = current[token]
-            else:
-                return _MISSING
+        current = _path_child(current, token)
+        if current is _MISSING:
+            return _MISSING
     return current
 
 
@@ -130,51 +137,67 @@ def _tokenize(rule: str) -> List[str]:
     return [placeholder.get(t, t) for t in tokens]
 
 
+def _rule_selector(tokens: List[str]) -> Tuple[str, str]:
+    selector = tokens.pop(0).lower()
+    if selector not in _SELECTORS:
+        raise AQLError(f"unknown selector {selector!r}; expected one of {', '.join(_SELECTORS)}")
+    if selector == "text":
+        return selector, ""
+    if not tokens:
+        raise AQLError(f"selector {selector!r} requires a path")
+    return selector, tokens.pop(0)
+
+
+def _predicate_value(tokens: List[str], message: str) -> str:
+    if tokens:
+        return tokens.pop(0)
+    raise AQLError(message)
+
+
+def _length_rule(selector: str, path: str, tokens: List[str], severity: str, raw: str) -> AQLRule:
+    if len(tokens) < 2 or tokens[0] not in _COMPARATORS:
+        raise AQLError("'length' requires an operator and number, e.g. length > 0")
+    operator, number = tokens[0], tokens[1]
+    if not number.lstrip("-").isdigit():
+        raise AQLError(f"'length' expects an integer, got {number!r}")
+    return AQLRule(selector, path, "length", number, length_op=operator, severity=severity, raw=raw)
+
+
+def _type_rule(selector: str, path: str, tokens: List[str], severity: str, raw: str) -> AQLRule:
+    value = _predicate_value(tokens, f"'type' requires one of {', '.join(sorted(_TYPE_NAMES))}").lower()
+    if value not in _TYPE_NAMES:
+        raise AQLError(f"'type' requires one of {', '.join(sorted(_TYPE_NAMES))}")
+    return AQLRule(selector, path, "type", value, severity=severity, raw=raw)
+
+
+def _predicate_rule(selector: str, path: str, keyword: str, tokens: List[str], severity: str, raw: str) -> AQLRule:
+    lower = keyword.lower()
+    if lower in ("exists", "missing"):
+        return AQLRule(selector, path, lower, severity=severity, raw=raw)
+    if lower == "matches":
+        return AQLRule(selector, path, "matches", _predicate_value(tokens, "'matches' requires a regex"), severity=severity, raw=raw)
+    if lower == "type":
+        return _type_rule(selector, path, tokens, severity, raw)
+    if lower == "length":
+        return _length_rule(selector, path, tokens, severity, raw)
+    if keyword in _COMPARATORS:
+        return AQLRule(selector, path, keyword, _predicate_value(tokens, f"operator {keyword!r} requires a value"), severity=severity, raw=raw)
+    raise AQLError(f"unknown predicate {keyword!r}")
+
+
 def parse_rule(rule: str) -> AQLRule:
     """Parse a single AQL rule string into an :class:`AQLRule`."""
     tokens, severity = _split_severity(_tokenize(rule))
     if not tokens:
         raise AQLError("empty rule")
 
-    selector = tokens.pop(0).lower()
-    if selector not in _SELECTORS:
-        raise AQLError(f"unknown selector {selector!r}; expected one of {', '.join(_SELECTORS)}")
-
-    path = ""
-    if selector != "text":
-        if not tokens:
-            raise AQLError(f"selector {selector!r} requires a path")
-        path = tokens.pop(0)
+    selector, path = _rule_selector(tokens)
 
     if not tokens:
         raise AQLError("rule requires a predicate (exists, =, length, type, …)")
 
     keyword = tokens.pop(0)
-    kw_lower = keyword.lower()
-
-    if kw_lower in ("exists", "missing"):
-        return AQLRule(selector, path, kw_lower, severity=severity, raw=rule)
-    if kw_lower == "matches":
-        if not tokens:
-            raise AQLError("'matches' requires a regex")
-        return AQLRule(selector, path, "matches", tokens.pop(0), severity=severity, raw=rule)
-    if kw_lower == "type":
-        if not tokens or tokens[0].lower() not in _TYPE_NAMES:
-            raise AQLError(f"'type' requires one of {', '.join(sorted(_TYPE_NAMES))}")
-        return AQLRule(selector, path, "type", tokens.pop(0).lower(), severity=severity, raw=rule)
-    if kw_lower == "length":
-        if len(tokens) < 2 or tokens[0] not in _COMPARATORS:
-            raise AQLError("'length' requires an operator and number, e.g. length > 0")
-        length_op, number = tokens[0], tokens[1]
-        if not number.lstrip("-").isdigit():
-            raise AQLError(f"'length' expects an integer, got {number!r}")
-        return AQLRule(selector, path, "length", number, length_op=length_op, severity=severity, raw=rule)
-    if keyword in _COMPARATORS:
-        if not tokens:
-            raise AQLError(f"operator {keyword!r} requires a value")
-        return AQLRule(selector, path, keyword, tokens.pop(0), severity=severity, raw=rule)
-
-    raise AQLError(f"unknown predicate {keyword!r}")
+    return _predicate_rule(selector, path, keyword, tokens, severity, rule)
 
 
 # --- evaluation -----------------------------------------------------------
@@ -220,26 +243,40 @@ def _type_name(value: Any) -> str:
     return "unknown"
 
 
-def _passes(rule: AQLRule, value: Any) -> bool:
-    present = value is not _MISSING
-    if rule.op == "exists":
-        return present
-    if rule.op == "missing":
-        return not present
-    if not present:
-        return False  # every other predicate needs the value to exist
-
+def _matches_value(rule: AQLRule, value: Any) -> bool:
     if rule.op == "matches":
         return re.search(rule.value, str(value)) is not None
     if rule.op == "type":
         wanted = "bool" if rule.value in ("bool", "boolean") else rule.value
         return _type_name(value) == wanted
+    return False
+
+
+def _collection_passes(rule: AQLRule, value: Any) -> bool | None:
     if rule.op == "length":
         length = _length_of(value)
         return length is not None and _compare(length, rule.length_op, rule.value)
     if rule.op in ("~", "!~"):
         contains = rule.value.lower() in str(value).lower()
         return contains if rule.op == "~" else not contains
+    return None
+
+
+def _passes(rule: AQLRule, value: Any) -> bool:
+    present = value is not _MISSING
+    if rule.op == "exists":
+        return present
+    if rule.op == "missing":
+        return not present
+    if not present:
+        return False  # every other predicate needs the value to exist
+
+    if rule.op in ("matches", "type"):
+        return _matches_value(rule, value)
+    if result := _collection_passes(rule, value):
+        return result
+    if rule.op in ("length", "~", "!~"):
+        return False
     return _compare(value, rule.op, rule.value)
 
 
@@ -259,6 +296,20 @@ class AQLEngine:
         except json.JSONDecodeError:
             return yaml.safe_load(text)
 
+    def _value_for_rule(self, file_path: Path, rule: AQLRule) -> Any:
+        data = self._load(file_path, rule.selector)
+        value = data if rule.selector == "text" else _resolve_path(data, rule.path)
+        return sorted(value.keys()) if rule.selector == "keys" and isinstance(value, dict) else value
+
+    @staticmethod
+    def _violation(file_path: Path, rule: AQLRule, value: Any) -> AnomalyResult:
+        shown = "(missing)" if value is _MISSING else repr(value)[:60]
+        return AnomalyResult(
+            detector="aql", file_path=str(file_path), anomaly_type="assertion", severity=rule.severity,
+            message=f"assertion failed: {rule.raw.strip()} (actual: {shown})",
+            details={"rule": rule.raw.strip(), "actual": None if value is _MISSING else value},
+        )
+
     def check_file(self, file_path: Path | str, rules: List[str | AQLRule]) -> List[AnomalyResult]:
         """Evaluate rules against one file; return a violation per failing rule."""
         file_path = Path(file_path)
@@ -269,24 +320,13 @@ class AQLEngine:
         for rule in rules:
             parsed = rule if isinstance(rule, AQLRule) else parse_rule(rule)
             try:
-                data = self._load(file_path, parsed.selector)
-                value = data if parsed.selector == "text" else _resolve_path(data, parsed.path)
-                if parsed.selector == "keys":
-                    value = sorted(value.keys()) if isinstance(value, dict) else value
+                value = self._value_for_rule(file_path, parsed)
             except (OSError, yaml.YAMLError) as exc:
                 violations.append(AnomalyResult("aql", str(file_path), "error", "high", f"could not read: {exc}"))
                 continue
 
             if not _passes(parsed, value):
-                shown = "(missing)" if value is _MISSING else repr(value)[:60]
-                violations.append(AnomalyResult(
-                    detector="aql",
-                    file_path=str(file_path),
-                    anomaly_type="assertion",
-                    severity=parsed.severity,
-                    message=f"assertion failed: {parsed.raw.strip()} (actual: {shown})",
-                    details={"rule": parsed.raw.strip(), "actual": None if value is _MISSING else value},
-                ))
+                violations.append(self._violation(file_path, parsed, value))
         return violations