rule-lab 0.1.1__tar.gz

rule_lab-0.1.1/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: rule-lab
+Version: 0.1.1
+Summary: WinstonRedGuard local-first deterministic rule evaluation engine
+Author-email: Yakuphan <yakuphan.yucel11@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yakuphanycl/WinstonRedGuard
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+
+# rule_lab
+
+Deterministik kural değerlendirme motoru. JSON kural dosyasını context listesine karşı simüle eder, çakışmaları tespit eder.
+
+## Kurulum
+```
+cd apps/rule_lab
+pip install -e ".[dev]"
+```
+
+## Kullanım
+```
+rule-lab validate --rules rules.json
+rule-lab simulate --rules rules.json --contexts contexts.json
+rule-lab diff --rules rules.json
+```

rule_lab-0.1.1/README.md

@@ -0,0 +1,16 @@
+# rule_lab
+
+Deterministik kural değerlendirme motoru. JSON kural dosyasını context listesine karşı simüle eder, çakışmaları tespit eder.
+
+## Kurulum
+```
+cd apps/rule_lab
+pip install -e ".[dev]"
+```
+
+## Kullanım
+```
+rule-lab validate --rules rules.json
+rule-lab simulate --rules rules.json --contexts contexts.json
+rule-lab diff --rules rules.json
+```

rule_lab-0.1.1/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rule-lab"
+version = "0.1.1"
+description = "WinstonRedGuard local-first deterministic rule evaluation engine"
+requires-python = ">=3.10"
+license = "MIT"
+readme = "README.md"
+authors = [
+  { name = "Yakuphan", email = "yakuphan.yucel11@gmail.com" }
+]
+
+[project.urls]
+Homepage = "https://github.com/yakuphanycl/WinstonRedGuard"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+]
+
+[project.scripts]
+rule-lab = "rule_lab.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

rule_lab-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rule_lab-0.1.1/src/rule_lab/__init__.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+APP_NAME = "rule_lab"
+APP_VERSION = "0.1.1"
+
+from rule_lab.core.contracts import Rule, EvaluationResult, BatchResult
+from rule_lab.core.models import RuleSet
+from rule_lab.core.evaluator import evaluate_rule, evaluate_rules, simulate
+from rule_lab.core.loader import load_rules_from_file, load_rules_from_dict, load_rules_from_list
+
+__all__ = [
+    "APP_NAME",
+    "APP_VERSION",
+    "Rule",
+    "EvaluationResult",
+    "BatchResult",
+    "RuleSet",
+    "evaluate_rule",
+    "evaluate_rules",
+    "simulate",
+    "load_rules_from_file",
+    "load_rules_from_dict",
+    "load_rules_from_list",
+]

rule_lab-0.1.1/src/rule_lab/cli.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, Sequence
+
+from rule_lab.core.conflicts import detect_conflicts
+from rule_lab.core.errors import RuleLabError
+from rule_lab.core.evaluator import evaluate_rules, simulate
+from rule_lab.core.loader import load_rules_from_file
+from rule_lab.core.reporting import build_batch_report, build_run_report, format_text_report, write_report
+
+
+class CliError(Exception):
+    pass
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="rule-lab", description="Deterministic rule evaluation engine")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    validate_parser = subparsers.add_parser("validate", help="Validate a rule file")
+    validate_parser.add_argument("--rules", required=True, help="Path to rules JSON file")
+
+    simulate_parser = subparsers.add_parser("simulate", help="Simulate rules against contexts")
+    simulate_parser.add_argument("--rules", required=True, help="Path to rules JSON file")
+    simulate_parser.add_argument("--contexts", required=True, help="Path to contexts JSON file (list of dicts)")
+    simulate_parser.add_argument("--out", help="Write JSON report to this path")
+    simulate_parser.add_argument("--json", action="store_true", help="Emit JSON to stdout")
+
+    diff_parser = subparsers.add_parser("diff", help="Detect conflicts between rules")
+    diff_parser.add_argument("--rules", required=True, help="Path to rules JSON file")
+    diff_parser.add_argument("--json", action="store_true", help="Emit JSON to stdout")
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        if args.command == "validate":
+            return _cmd_validate(args)
+        if args.command == "simulate":
+            return _cmd_simulate(args)
+        if args.command == "diff":
+            return _cmd_diff(args)
+        raise CliError(f"unsupported command: {args.command}")
+    except CliError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 1
+    except RuleLabError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 1
+    except FileNotFoundError as exc:
+        print(f"ERROR: file not found: {exc.filename or exc}", file=sys.stderr)
+        return 1
+    except json.JSONDecodeError as exc:
+        print(f"ERROR: invalid JSON: {exc}", file=sys.stderr)
+        return 1
+
+
+def _cmd_validate(args: argparse.Namespace) -> int:
+    rules = load_rules_from_file(args.rules)
+    print(f"validate OK — {len(rules)} rule(s) loaded from {args.rules}")
+    return 0
+
+
+def _cmd_simulate(args: argparse.Namespace) -> int:
+    rules = load_rules_from_file(args.rules)
+    contexts_path = Path(args.contexts)
+    if not contexts_path.exists():
+        raise CliError(f"contexts file not found: {contexts_path}")
+    contexts: list[dict[str, Any]] = json.loads(contexts_path.read_text(encoding="utf-8"))
+    if not isinstance(contexts, list):
+        raise CliError("contexts file must contain a JSON array")
+
+    conflicts = detect_conflicts(rules)
+    batch_results = simulate(rules, contexts)
+    report = build_batch_report(batch_results, conflicts, contexts)
+
+    if args.json:
+        print(json.dumps(report, indent=2, ensure_ascii=False))
+    else:
+        print(format_text_report({
+            "total_rules": report["total_rules"],
+            "matched_count": sum(r["matched_count"] for r in report["runs"]),
+            "conflict_count": report["conflict_count"],
+            "results": [res for run in report["runs"] for res in run["results"]],
+            "conflicts": report["conflicts"],
+        }))
+
+    if args.out:
+        write_report(report, args.out)
+        print(f"report written to {args.out}")
+
+    return 0
+
+
+def _cmd_diff(args: argparse.Namespace) -> int:
+    rules = load_rules_from_file(args.rules)
+    conflicts = detect_conflicts(rules)
+
+    if args.json:
+        print(json.dumps([c.to_dict() for c in conflicts], indent=2, ensure_ascii=False))
+    else:
+        if not conflicts:
+            print("diff: no conflicts detected")
+        else:
+            for c in conflicts:
+                print(f"CONFLICT {c.rule_a} vs {c.rule_b}: {c.message}")
+
+    return 1 if conflicts else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

rule_lab-0.1.1/src/rule_lab/core/__init__.py

@@ -0,0 +1,2 @@
+from __future__ import annotations
+

rule_lab-0.1.1/src/rule_lab/core/conditions.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .errors import ConditionError
+
+SUPPORTED_OPERATORS = {"eq", "neq", "gt", "gte", "lt", "lte", "contains", "not_contains", "exists", "not_exists"}
+
+
+def evaluate_condition(condition: dict[str, Any], context: dict[str, Any]) -> bool:
+    """Evaluate a single condition against a context dict.
+
+    Condition shape:
+        {"field": "score", "op": "gte", "value": 7.0}
+    """
+    field = condition.get("field")
+    op = condition.get("op")
+    expected = condition.get("value")
+
+    if not isinstance(field, str) or not field.strip():
+        raise ConditionError(f"condition missing 'field': {condition}")
+    if op not in SUPPORTED_OPERATORS:
+        raise ConditionError(f"unsupported operator '{op}' in condition: {condition}")
+
+    actual = context.get(field)
+
+    if op == "exists":
+        return field in context
+    if op == "not_exists":
+        return field not in context
+
+    if actual is None:
+        return False
+
+    if op == "eq":
+        return actual == expected
+    if op == "neq":
+        return actual != expected
+    if op == "gt":
+        return float(actual) > float(expected)
+    if op == "gte":
+        return float(actual) >= float(expected)
+    if op == "lt":
+        return float(actual) < float(expected)
+    if op == "lte":
+        return float(actual) <= float(expected)
+    if op == "contains":
+        return str(expected) in str(actual)
+    if op == "not_contains":
+        return str(expected) not in str(actual)
+
+    raise ConditionError(f"unhandled operator '{op}'")
+
+
+def evaluate_all(conditions: list[dict[str, Any]], context: dict[str, Any]) -> tuple[int, int]:
+    """Evaluate all conditions. Returns (total_checked, total_passed)."""
+    passed = sum(1 for c in conditions if evaluate_condition(c, context))
+    return len(conditions), passed

rule_lab-0.1.1/src/rule_lab/core/conflicts.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from .contracts import ConflictReport, Rule
+
+
+def detect_conflicts(rules: list[Rule]) -> list[ConflictReport]:
+    """Detect same-priority rules with the same conditions but different actions."""
+    conflicts: list[ConflictReport] = []
+    seen: list[Rule] = []
+
+    for rule in rules:
+        for other in seen:
+            if _conditions_overlap(rule, other) and rule.action != other.action:
+                conflicts.append(
+                    ConflictReport(
+                        rule_a=rule.rule_id,
+                        rule_b=other.rule_id,
+                        conflict_type="action_conflict",
+                        message=(
+                            f"Rules '{rule.rule_id}' and '{other.rule_id}' have overlapping "
+                            f"conditions but different actions: '{rule.action}' vs '{other.action}'"
+                        ),
+                    )
+                )
+        seen.append(rule)
+
+    return conflicts
+
+
+def _conditions_overlap(a: Rule, b: Rule) -> bool:
+    """True if both rules share at least one identical condition dict."""
+    if not a.conditions or not b.conditions:
+        return False
+    b_conditions = b.conditions
+    return any(cond in b_conditions for cond in a.conditions)

rule_lab-0.1.1/src/rule_lab/core/contracts.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True)
+class Rule:
+    rule_id: str
+    name: str
+    conditions: list[dict[str, Any]]
+    action: str
+    priority: int = 0
+    tags: list[str] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "rule_id": self.rule_id,
+            "name": self.name,
+            "conditions": self.conditions,
+            "action": self.action,
+            "priority": self.priority,
+            "tags": self.tags,
+            "metadata": self.metadata,
+        }
+
+
+@dataclass(slots=True)
+class EvaluationResult:
+    rule_id: str
+    rule_name: str
+    matched: bool
+    action: str | None
+    reason: str
+    conditions_checked: int
+    conditions_passed: int
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "rule_id": self.rule_id,
+            "rule_name": self.rule_name,
+            "matched": self.matched,
+            "action": self.action if self.matched else None,
+            "reason": self.reason,
+            "conditions_checked": self.conditions_checked,
+            "conditions_passed": self.conditions_passed,
+        }
+
+
+@dataclass(slots=True)
+class BatchResult:
+    total_rules: int
+    matched_count: int
+    results: list[EvaluationResult]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "total_rules": self.total_rules,
+            "matched_count": self.matched_count,
+            "results": [r.to_dict() for r in self.results],
+        }
+
+
+@dataclass(slots=True)
+class ConflictReport:
+    rule_a: str
+    rule_b: str
+    conflict_type: str
+    message: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "rule_a": self.rule_a,
+            "rule_b": self.rule_b,
+            "conflict_type": self.conflict_type,
+            "message": self.message,
+        }

rule_lab-0.1.1/src/rule_lab/core/errors.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+
+class RuleLabError(Exception):
+    """Base error for rule_lab."""
+
+
+class RuleLoadError(RuleLabError):
+    """Raised when a rule file cannot be loaded or parsed."""
+
+
+class RuleValidationError(RuleLabError):
+    """Raised when a rule definition fails schema validation."""
+
+
+class ConditionError(RuleLabError):
+    """Raised when a condition cannot be evaluated."""

rule_lab-0.1.1/src/rule_lab/core/evaluator.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .conditions import evaluate_all
+from .contracts import BatchResult, EvaluationResult, Rule
+
+
+def evaluate_rule(rule: Rule, context: dict[str, Any]) -> EvaluationResult:
+    if not rule.conditions:
+        return EvaluationResult(
+            rule_id=rule.rule_id,
+            rule_name=rule.name,
+            matched=True,
+            action=rule.action,
+            reason="no conditions — unconditional match",
+            conditions_checked=0,
+            conditions_passed=0,
+        )
+
+    total, passed = evaluate_all(rule.conditions, context)
+    matched = passed == total
+
+    return EvaluationResult(
+        rule_id=rule.rule_id,
+        rule_name=rule.name,
+        matched=matched,
+        action=rule.action if matched else None,
+        reason=f"{passed}/{total} conditions passed",
+        conditions_checked=total,
+        conditions_passed=passed,
+    )
+
+
+def evaluate_rules(rules: list[Rule], context: dict[str, Any]) -> BatchResult:
+    results = [evaluate_rule(rule, context) for rule in rules]
+    matched = [r for r in results if r.matched]
+    return BatchResult(
+        total_rules=len(rules),
+        matched_count=len(matched),
+        results=results,
+    )
+
+
+def simulate(rules: list[Rule], contexts: list[dict[str, Any]]) -> list[BatchResult]:
+    return [evaluate_rules(rules, ctx) for ctx in contexts]

rule_lab-0.1.1/src/rule_lab/core/loader.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .contracts import Rule
+from .errors import RuleLoadError, RuleValidationError
+
+REQUIRED_RULE_FIELDS = {"rule_id", "name", "conditions", "action"}
+
+
+def _validate_rule_dict(raw: dict[str, Any]) -> None:
+    missing = REQUIRED_RULE_FIELDS - set(raw.keys())
+    if missing:
+        raise RuleValidationError(f"rule missing required fields: {sorted(missing)}")
+    if not isinstance(raw["conditions"], list):
+        raise RuleValidationError(f"rule '{raw['rule_id']}': conditions must be a list")
+    if not isinstance(raw["action"], str) or not raw["action"].strip():
+        raise RuleValidationError(f"rule '{raw['rule_id']}': action must be a non-empty string")
+
+
+def load_rules_from_dict(data: dict[str, Any]) -> list[Rule]:
+    raw_rules = data.get("rules", [])
+    if not isinstance(raw_rules, list):
+        raise RuleLoadError("ruleset 'rules' field must be a list")
+
+    rules: list[Rule] = []
+    for raw in raw_rules:
+        if not isinstance(raw, dict):
+            raise RuleLoadError(f"rule entry must be a dict, got: {type(raw)}")
+        _validate_rule_dict(raw)
+        rules.append(
+            Rule(
+                rule_id=str(raw["rule_id"]),
+                name=str(raw["name"]),
+                conditions=list(raw["conditions"]),
+                action=str(raw["action"]),
+                priority=int(raw.get("priority", 0)),
+                tags=list(raw.get("tags", [])),
+                metadata=dict(raw.get("metadata", {})),
+            )
+        )
+    return sorted(rules, key=lambda r: (-r.priority, r.rule_id))
+
+
+def load_rules_from_file(path: str | Path) -> list[Rule]:
+    p = Path(path)
+    if not p.exists():
+        raise RuleLoadError(f"rule file not found: {p}")
+    try:
+        data = json.loads(p.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise RuleLoadError(f"invalid JSON in rule file {p}: {exc}") from exc
+    if not isinstance(data, dict):
+        raise RuleLoadError(f"rule file must contain a JSON object: {p}")
+    return load_rules_from_dict(data)
+
+
+def load_rules_from_list(raw_rules: list[dict[str, Any]]) -> list[Rule]:
+    return load_rules_from_dict({"rules": raw_rules})

rule_lab-0.1.1/src/rule_lab/core/models.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True)
+class RuleSet:
+    name: str
+    version: str
+    rules: list[dict[str, Any]] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "version": self.version,
+            "rules": self.rules,
+            "metadata": self.metadata,
+        }

rule_lab-0.1.1/src/rule_lab/core/reporting.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .contracts import BatchResult, ConflictReport
+
+
+def build_run_report(
+    batch: BatchResult,
+    conflicts: list[ConflictReport],
+    context: dict[str, Any],
+) -> dict[str, Any]:
+    return {
+        "context": context,
+        "total_rules": batch.total_rules,
+        "matched_count": batch.matched_count,
+        "conflict_count": len(conflicts),
+        "results": [r.to_dict() for r in batch.results],
+        "conflicts": [c.to_dict() for c in conflicts],
+    }
+
+
+def build_batch_report(
+    batch_results: list[BatchResult],
+    conflicts: list[ConflictReport],
+    contexts: list[dict[str, Any]],
+) -> dict[str, Any]:
+    return {
+        "total_contexts": len(contexts),
+        "total_rules": batch_results[0].total_rules if batch_results else 0,
+        "conflict_count": len(conflicts),
+        "conflicts": [c.to_dict() for c in conflicts],
+        "runs": [
+            {
+                "context_index": i,
+                "matched_count": r.matched_count,
+                "results": [res.to_dict() for res in r.results],
+            }
+            for i, r in enumerate(batch_results)
+        ],
+    }
+
+
+def format_text_report(report: dict[str, Any]) -> str:
+    lines = [f"rule_lab report:"]
+    lines.append(f"  total_rules    : {report.get('total_rules', '?')}")
+    lines.append(f"  matched_count  : {report.get('matched_count', '?')}")
+    lines.append(f"  conflict_count : {report.get('conflict_count', 0)}")
+    for result in report.get("results", []):
+        status = "MATCH" if result["matched"] else "miss"
+        lines.append(f"  [{status}] {result['rule_id']} — {result['reason']}")
+    if report.get("conflicts"):
+        lines.append("  conflicts:")
+        for c in report["conflicts"]:
+            lines.append(f"    {c['rule_a']} vs {c['rule_b']}: {c['message']}")
+    return "\n".join(lines)
+
+
+def write_report(report: dict[str, Any], path: str | Path) -> None:
+    out = Path(path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")

rule_lab-0.1.1/src/rule_lab.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: rule-lab
+Version: 0.1.1
+Summary: WinstonRedGuard local-first deterministic rule evaluation engine
+Author-email: Yakuphan <yakuphan.yucel11@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yakuphanycl/WinstonRedGuard
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+
+# rule_lab
+
+Deterministik kural değerlendirme motoru. JSON kural dosyasını context listesine karşı simüle eder, çakışmaları tespit eder.
+
+## Kurulum
+```
+cd apps/rule_lab
+pip install -e ".[dev]"
+```
+
+## Kullanım
+```
+rule-lab validate --rules rules.json
+rule-lab simulate --rules rules.json --contexts contexts.json
+rule-lab diff --rules rules.json
+```

rule_lab-0.1.1/src/rule_lab.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+README.md
+pyproject.toml
+src/rule_lab/__init__.py
+src/rule_lab/cli.py
+src/rule_lab.egg-info/PKG-INFO
+src/rule_lab.egg-info/SOURCES.txt
+src/rule_lab.egg-info/dependency_links.txt
+src/rule_lab.egg-info/entry_points.txt
+src/rule_lab.egg-info/requires.txt
+src/rule_lab.egg-info/top_level.txt
+src/rule_lab/core/__init__.py
+src/rule_lab/core/conditions.py
+src/rule_lab/core/conflicts.py
+src/rule_lab/core/contracts.py
+src/rule_lab/core/errors.py
+src/rule_lab/core/evaluator.py
+src/rule_lab/core/loader.py
+src/rule_lab/core/models.py
+src/rule_lab/core/reporting.py
+tests/test_batch.py
+tests/test_cli.py
+tests/test_conditions.py
+tests/test_diff.py
+tests/test_metadata_consistency.py
+tests/test_simulate.py
+tests/test_validate.py

rule_lab-0.1.1/src/rule_lab.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rule_lab-0.1.1/src/rule_lab.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rule-lab = rule_lab.cli:main

rule_lab-0.1.1/src/rule_lab.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=8

rule_lab-0.1.1/src/rule_lab.egg-info/top_level.txt

@@ -0,0 +1 @@
+rule_lab

rule_lab-0.1.1/tests/test_batch.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+import json
+from pathlib import Path
+from rule_lab.core.contracts import Rule
+from rule_lab.core.evaluator import evaluate_rules, simulate
+from rule_lab.core.conflicts import detect_conflicts
+from rule_lab.core.reporting import build_run_report, build_batch_report, format_text_report, write_report
+
+
+def _rule(rule_id: str, conditions: list, action: str) -> Rule:
+    return Rule(rule_id=rule_id, name=rule_id, conditions=conditions, action=action)
+
+
+RULE_KEEP = _rule("r1", [{"field": "score", "op": "gte", "value": 7.0}], "keep")
+RULE_DISCARD = _rule("r2", [{"field": "score", "op": "lt", "value": 4.0}], "discard")
+
+
+def test_build_run_report_shape():
+    ctx = {"score": 8.0}
+    batch = evaluate_rules([RULE_KEEP, RULE_DISCARD], ctx)
+    conflicts = detect_conflicts([RULE_KEEP, RULE_DISCARD])
+    report = build_run_report(batch, conflicts, ctx)
+
+    for key in ("context", "total_rules", "matched_count", "conflict_count", "results", "conflicts"):
+        assert key in report
+
+
+def test_build_batch_report_shape():
+    contexts = [{"score": 8.0}, {"score": 2.0}]
+    results = simulate([RULE_KEEP, RULE_DISCARD], contexts)
+    conflicts = detect_conflicts([RULE_KEEP, RULE_DISCARD])
+    report = build_batch_report(results, conflicts, contexts)
+
+    assert report["total_contexts"] == 2
+    assert report["total_rules"] == 2
+    assert len(report["runs"]) == 2
+
+
+def test_format_text_report_is_string():
+    ctx = {"score": 8.0}
+    batch = evaluate_rules([RULE_KEEP], ctx)
+    report = build_run_report(batch, [], ctx)
+    text = format_text_report(report)
+    assert isinstance(text, str)
+    assert "rule_lab report" in text
+
+
+def test_write_report_creates_file(tmp_path: Path):
+    ctx = {"score": 8.0}
+    batch = evaluate_rules([RULE_KEEP], ctx)
+    report = build_run_report(batch, [], ctx)
+    out = tmp_path / "out" / "report.json"
+    write_report(report, out)
+    assert out.exists()
+    parsed = json.loads(out.read_text(encoding="utf-8"))
+    assert "total_rules" in parsed

rule_lab-0.1.1/tests/test_cli.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from rule_lab.cli import main
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+VALID_RULE = {
+    "rule_id": "r1",
+    "name": "Score threshold",
+    "conditions": [{"field": "score", "op": "gte", "value": 7.0}],
+    "action": "keep",
+    "priority": 1,
+}
+
+CONFLICTING_RULE = {
+    "rule_id": "r2",
+    "name": "Score threshold conflict",
+    "conditions": [{"field": "score", "op": "gte", "value": 7.0}],
+    "action": "discard",
+    "priority": 1,
+}
+
+
+def _write_rules(path: Path, rules: list) -> None:
+    path.write_text(json.dumps({"rules": rules}), encoding="utf-8")
+
+
+def _write_contexts(path: Path, contexts: list) -> None:
+    path.write_text(json.dumps(contexts), encoding="utf-8")
+
+
+# ---------------------------------------------------------------------------
+# validate
+# ---------------------------------------------------------------------------
+
+def test_validate_ok(tmp_path: Path) -> None:
+    rules_file = tmp_path / "rules.json"
+    _write_rules(rules_file, [VALID_RULE])
+    rc = main(["validate", "--rules", str(rules_file)])
+    assert rc == 0
+
+
+def test_validate_missing_file_returns_nonzero() -> None:
+    rc = main(["validate", "--rules", "/nonexistent/rules.json"])
+    assert rc != 0
+
+
+def test_validate_invalid_json(tmp_path: Path) -> None:
+    rules_file = tmp_path / "bad.json"
+    rules_file.write_text("NOT JSON", encoding="utf-8")
+    rc = main(["validate", "--rules", str(rules_file)])
+    assert rc != 0
+
+
+# ---------------------------------------------------------------------------
+# simulate
+# ---------------------------------------------------------------------------
+
+def test_simulate_ok(tmp_path: Path) -> None:
+    rules_file = tmp_path / "rules.json"
+    contexts_file = tmp_path / "contexts.json"
+    _write_rules(rules_file, [VALID_RULE])
+    _write_contexts(contexts_file, [{"score": 8.0}, {"score": 3.0}])
+    rc = main(["simulate", "--rules", str(rules_file), "--contexts", str(contexts_file)])
+    assert rc == 0
+
+
+def test_simulate_json_flag(tmp_path: Path) -> None:
+    rules_file = tmp_path / "rules.json"
+    contexts_file = tmp_path / "contexts.json"
+    _write_rules(rules_file, [VALID_RULE])
+    _write_contexts(contexts_file, [{"score": 8.0}])
+    rc = main(["simulate", "--rules", str(rules_file), "--contexts", str(contexts_file), "--json"])
+    assert rc == 0
+
+
+def test_simulate_writes_out_file(tmp_path: Path) -> None:
+    rules_file = tmp_path / "rules.json"
+    contexts_file = tmp_path / "contexts.json"
+    out_file = tmp_path / "report.json"
+    _write_rules(rules_file, [VALID_RULE])
+    _write_contexts(contexts_file, [{"score": 8.0}])
+    rc = main(["simulate", "--rules", str(rules_file), "--contexts", str(contexts_file), "--out", str(out_file)])
+    assert rc == 0
+    assert out_file.exists()
+    parsed = json.loads(out_file.read_text(encoding="utf-8"))
+    assert "runs" in parsed
+
+
+def test_simulate_missing_contexts_returns_nonzero(tmp_path: Path) -> None:
+    rules_file = tmp_path / "rules.json"
+    _write_rules(rules_file, [VALID_RULE])
+    rc = main(["simulate", "--rules", str(rules_file), "--contexts", str(tmp_path / "missing.json")])
+    assert rc != 0
+
+
+# ---------------------------------------------------------------------------
+# diff
+# ---------------------------------------------------------------------------
+
+def test_diff_no_conflicts_returns_zero(tmp_path: Path) -> None:
+    rules_file = tmp_path / "rules.json"
+    _write_rules(rules_file, [VALID_RULE])
+    rc = main(["diff", "--rules", str(rules_file)])
+    assert rc == 0
+
+
+def test_diff_with_conflicts_returns_nonzero(tmp_path: Path) -> None:
+    rules_file = tmp_path / "rules.json"
+    _write_rules(rules_file, [VALID_RULE, CONFLICTING_RULE])
+    rc = main(["diff", "--rules", str(rules_file)])
+    assert rc != 0
+
+
+def test_diff_json_flag(tmp_path: Path) -> None:
+    rules_file = tmp_path / "rules.json"
+    _write_rules(rules_file, [VALID_RULE, CONFLICTING_RULE])
+    rc = main(["diff", "--rules", str(rules_file), "--json"])
+    assert rc != 0

rule_lab-0.1.1/tests/test_conditions.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+from rule_lab.core.conditions import evaluate_condition, evaluate_all
+from rule_lab.core.errors import ConditionError
+import pytest
+
+
+def test_eq_match():
+    assert evaluate_condition({"field": "status", "op": "eq", "value": "active"}, {"status": "active"})
+
+
+def test_eq_no_match():
+    assert not evaluate_condition({"field": "status", "op": "eq", "value": "active"}, {"status": "inactive"})
+
+
+def test_gte_match():
+    assert evaluate_condition({"field": "score", "op": "gte", "value": 7.0}, {"score": 8.5})
+
+
+def test_gte_no_match():
+    assert not evaluate_condition({"field": "score", "op": "gte", "value": 7.0}, {"score": 5.0})
+
+
+def test_lt_match():
+    assert evaluate_condition({"field": "age", "op": "lt", "value": 30}, {"age": 25})
+
+
+def test_contains_match():
+    assert evaluate_condition({"field": "tag", "op": "contains", "value": "lab"}, {"tag": "rule_lab"})
+
+
+def test_not_contains_match():
+    assert evaluate_condition({"field": "tag", "op": "not_contains", "value": "prod"}, {"tag": "dev"})
+
+
+def test_exists_true():
+    assert evaluate_condition({"field": "score", "op": "exists"}, {"score": 0})
+
+
+def test_exists_false():
+    assert not evaluate_condition({"field": "score", "op": "exists"}, {})
+
+
+def test_not_exists_true():
+    assert evaluate_condition({"field": "missing", "op": "not_exists"}, {})
+
+
+def test_missing_field_returns_false():
+    assert not evaluate_condition({"field": "score", "op": "eq", "value": 5}, {})
+
+
+def test_unsupported_operator_raises():
+    with pytest.raises(ConditionError):
+        evaluate_condition({"field": "x", "op": "regex", "value": ".*"}, {"x": "hello"})
+
+
+def test_missing_field_key_raises():
+    with pytest.raises(ConditionError):
+        evaluate_condition({"op": "eq", "value": 1}, {"x": 1})
+
+
+def test_evaluate_all_counts():
+    conditions = [
+        {"field": "score", "op": "gte", "value": 5.0},
+        {"field": "status", "op": "eq", "value": "ok"},
+    ]
+    total, passed = evaluate_all(conditions, {"score": 8.0, "status": "ok"})
+    assert total == 2
+    assert passed == 2
+
+
+def test_evaluate_all_partial():
+    conditions = [
+        {"field": "score", "op": "gte", "value": 5.0},
+        {"field": "status", "op": "eq", "value": "ok"},
+    ]
+    total, passed = evaluate_all(conditions, {"score": 8.0, "status": "fail"})
+    assert total == 2
+    assert passed == 1

rule_lab-0.1.1/tests/test_diff.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+from rule_lab.core.contracts import Rule
+from rule_lab.core.conflicts import detect_conflicts
+
+
+def _rule(rule_id: str, conditions: list, action: str) -> Rule:
+    return Rule(rule_id=rule_id, name=rule_id, conditions=conditions, action=action)
+
+
+COND_A = {"field": "score", "op": "gte", "value": 7.0}
+COND_B = {"field": "status", "op": "eq", "value": "ok"}
+
+
+def test_no_conflicts_when_same_action():
+    rules = [
+        _rule("r1", [COND_A], "keep"),
+        _rule("r2", [COND_A], "keep"),
+    ]
+    assert detect_conflicts(rules) == []
+
+
+def test_conflict_detected_when_different_actions():
+    rules = [
+        _rule("r1", [COND_A], "keep"),
+        _rule("r2", [COND_A], "discard"),
+    ]
+    conflicts = detect_conflicts(rules)
+    assert len(conflicts) == 1
+    assert conflicts[0].conflict_type == "action_conflict"
+    assert "r1" in conflicts[0].rule_a or "r1" in conflicts[0].rule_b
+
+
+def test_no_conflict_when_conditions_differ():
+    rules = [
+        _rule("r1", [COND_A], "keep"),
+        _rule("r2", [COND_B], "discard"),
+    ]
+    assert detect_conflicts(rules) == []
+
+
+def test_no_conflict_when_no_conditions():
+    rules = [
+        _rule("r1", [], "keep"),
+        _rule("r2", [], "discard"),
+    ]
+    assert detect_conflicts(rules) == []
+
+
+def test_conflict_report_to_dict():
+    rules = [
+        _rule("r1", [COND_A], "keep"),
+        _rule("r2", [COND_A], "discard"),
+    ]
+    conflicts = detect_conflicts(rules)
+    d = conflicts[0].to_dict()
+    for key in ("rule_a", "rule_b", "conflict_type", "message"):
+        assert key in d
+
+
+def test_multiple_conflicts():
+    rules = [
+        _rule("r1", [COND_A], "keep"),
+        _rule("r2", [COND_A], "discard"),
+        _rule("r3", [COND_A], "review"),
+    ]
+    conflicts = detect_conflicts(rules)
+    assert len(conflicts) >= 2

rule_lab-0.1.1/tests/test_metadata_consistency.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from rule_lab.core.contracts import Rule
+from rule_lab.core.evaluator import evaluate_rule, evaluate_rules
+from rule_lab.core.loader import load_rules_from_list
+from rule_lab.core.models import RuleSet
+
+
+# ---------------------------------------------------------------------------
+# Rule metadata round-trip
+# ---------------------------------------------------------------------------
+
+def test_rule_metadata_survives_loader() -> None:
+    raw = [{
+        "rule_id": "r1",
+        "name": "Meta rule",
+        "conditions": [{"field": "score", "op": "gte", "value": 5.0}],
+        "action": "keep",
+        "tags": ["important", "v2"],
+        "metadata": {"author": "yakuphan", "version": "0.2"},
+    }]
+    rules = load_rules_from_list(raw)
+    assert rules[0].metadata == {"author": "yakuphan", "version": "0.2"}
+    assert rules[0].tags == ["important", "v2"]
+
+
+def test_rule_metadata_in_to_dict() -> None:
+    rule = Rule(
+        rule_id="r1",
+        name="test",
+        conditions=[],
+        action="keep",
+        tags=["x"],
+        metadata={"source": "unit_test"},
+    )
+    d = rule.to_dict()
+    assert d["metadata"] == {"source": "unit_test"}
+    assert d["tags"] == ["x"]
+
+
+def test_rule_metadata_empty_by_default() -> None:
+    raw = [{
+        "rule_id": "r2",
+        "name": "No meta",
+        "conditions": [],
+        "action": "pass",
+    }]
+    rules = load_rules_from_list(raw)
+    assert rules[0].metadata == {}
+    assert rules[0].tags == []
+
+
+# ---------------------------------------------------------------------------
+# RuleSet model
+# ---------------------------------------------------------------------------
+
+def test_ruleset_to_dict_shape() -> None:
+    rs = RuleSet(
+        name="test_set",
+        version="1.0",
+        rules=[{"rule_id": "r1", "name": "x", "conditions": [], "action": "keep"}],
+        metadata={"owner": "team_a"},
+    )
+    d = rs.to_dict()
+    assert d["name"] == "test_set"
+    assert d["version"] == "1.0"
+    assert d["metadata"] == {"owner": "team_a"}
+    assert len(d["rules"]) == 1
+
+
+def test_ruleset_empty_metadata_by_default() -> None:
+    rs = RuleSet(name="empty", version="0.1")
+    assert rs.metadata == {}
+    assert rs.rules == []
+
+
+# ---------------------------------------------------------------------------
+# Metadata does not affect evaluation
+# ---------------------------------------------------------------------------
+
+def test_metadata_does_not_affect_match_result() -> None:
+    rule_with_meta = Rule(
+        rule_id="r1",
+        name="with meta",
+        conditions=[{"field": "score", "op": "gte", "value": 7.0}],
+        action="keep",
+        metadata={"note": "some annotation"},
+    )
+    rule_without_meta = Rule(
+        rule_id="r2",
+        name="without meta",
+        conditions=[{"field": "score", "op": "gte", "value": 7.0}],
+        action="keep",
+    )
+    ctx = {"score": 8.0}
+    result_a = evaluate_rule(rule_with_meta, ctx)
+    result_b = evaluate_rule(rule_without_meta, ctx)
+
+    assert result_a.matched == result_b.matched
+    assert result_a.action == result_b.action
+
+
+# ---------------------------------------------------------------------------
+# Priority metadata
+# ---------------------------------------------------------------------------
+
+def test_priority_preserved_in_to_dict() -> None:
+    raw = [
+        {"rule_id": "low", "name": "low", "conditions": [], "action": "pass", "priority": 1},
+        {"rule_id": "high", "name": "high", "conditions": [], "action": "pass", "priority": 10},
+    ]
+    rules = load_rules_from_list(raw)
+    dicts = [r.to_dict() for r in rules]
+    priorities = [d["priority"] for d in dicts]
+    assert 10 in priorities
+    assert 1 in priorities
+
+
+def test_evaluation_result_does_not_leak_metadata() -> None:
+    rule = Rule(
+        rule_id="r1",
+        name="meta check",
+        conditions=[{"field": "x", "op": "eq", "value": 1}],
+        action="keep",
+        metadata={"secret": "internal"},
+    )
+    result = evaluate_rule(rule, {"x": 1})
+    d = result.to_dict()
+    assert "metadata" not in d
+    assert "secret" not in d

rule_lab-0.1.1/tests/test_simulate.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+from rule_lab.core.contracts import Rule
+from rule_lab.core.evaluator import evaluate_rule, evaluate_rules, simulate
+
+
+def _rule(rule_id: str, conditions: list, action: str, priority: int = 0) -> Rule:
+    return Rule(rule_id=rule_id, name=rule_id, conditions=conditions, action=action, priority=priority)
+
+
+SCORE_RULE = _rule("r1", [{"field": "score", "op": "gte", "value": 7.0}], "keep")
+STATUS_RULE = _rule("r2", [{"field": "status", "op": "eq", "value": "ok"}], "promote")
+NO_COND_RULE = _rule("r3", [], "default_action")
+
+
+def test_evaluate_rule_match():
+    result = evaluate_rule(SCORE_RULE, {"score": 8.0})
+    assert result.matched is True
+    assert result.action == "keep"
+
+
+def test_evaluate_rule_no_match():
+    result = evaluate_rule(SCORE_RULE, {"score": 5.0})
+    assert result.matched is False
+    assert result.action is None
+
+
+def test_evaluate_rule_no_conditions_always_matches():
+    result = evaluate_rule(NO_COND_RULE, {})
+    assert result.matched is True
+    assert result.action == "default_action"
+
+
+def test_evaluate_rule_result_fields():
+    result = evaluate_rule(SCORE_RULE, {"score": 9.0})
+    assert result.rule_id == "r1"
+    assert result.conditions_checked == 1
+    assert result.conditions_passed == 1
+    assert isinstance(result.reason, str)
+
+
+def test_evaluate_rules_batch():
+    rules = [SCORE_RULE, STATUS_RULE]
+    batch = evaluate_rules(rules, {"score": 8.0, "status": "ok"})
+    assert batch.total_rules == 2
+    assert batch.matched_count == 2
+
+
+def test_evaluate_rules_partial_match():
+    rules = [SCORE_RULE, STATUS_RULE]
+    batch = evaluate_rules(rules, {"score": 3.0, "status": "ok"})
+    assert batch.matched_count == 1
+
+
+def test_evaluate_rules_no_match():
+    rules = [SCORE_RULE]
+    batch = evaluate_rules(rules, {"score": 1.0})
+    assert batch.matched_count == 0
+
+
+def test_simulate_multiple_contexts():
+    rules = [SCORE_RULE]
+    contexts = [{"score": 8.0}, {"score": 2.0}, {"score": 7.0}]
+    results = simulate(rules, contexts)
+    assert len(results) == 3
+    assert results[0].matched_count == 1
+    assert results[1].matched_count == 0
+    assert results[2].matched_count == 1
+
+
+def test_to_dict_shape():
+    result = evaluate_rule(SCORE_RULE, {"score": 8.0})
+    d = result.to_dict()
+    for key in ("rule_id", "rule_name", "matched", "action", "reason", "conditions_checked", "conditions_passed"):
+        assert key in d

rule_lab-0.1.1/tests/test_validate.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+import json
+from pathlib import Path
+import pytest
+from rule_lab.core.loader import load_rules_from_dict, load_rules_from_file, load_rules_from_list
+from rule_lab.core.errors import RuleLoadError, RuleValidationError
+
+
+VALID_RULE = {
+    "rule_id": "r1",
+    "name": "Score threshold",
+    "conditions": [{"field": "score", "op": "gte", "value": 7.0}],
+    "action": "keep",
+    "priority": 5,
+}
+
+
+def test_load_from_dict():
+    rules = load_rules_from_dict({"rules": [VALID_RULE]})
+    assert len(rules) == 1
+    assert rules[0].rule_id == "r1"
+    assert rules[0].action == "keep"
+
+
+def test_load_from_list():
+    rules = load_rules_from_list([VALID_RULE])
+    assert len(rules) == 1
+
+
+def test_load_empty_ruleset():
+    rules = load_rules_from_dict({"rules": []})
+    assert rules == []
+
+
+def test_missing_required_field_raises():
+    bad = {k: v for k, v in VALID_RULE.items() if k != "action"}
+    with pytest.raises(RuleValidationError, match="action"):
+        load_rules_from_list([bad])
+
+
+def test_conditions_not_list_raises():
+    bad = {**VALID_RULE, "conditions": "not_a_list"}
+    with pytest.raises(RuleValidationError):
+        load_rules_from_list([bad])
+
+
+def test_rules_field_not_list_raises():
+    with pytest.raises(RuleLoadError):
+        load_rules_from_dict({"rules": "bad"})
+
+
+def test_load_from_file(tmp_path: Path):
+    f = tmp_path / "rules.json"
+    f.write_text(json.dumps({"rules": [VALID_RULE]}), encoding="utf-8")
+    rules = load_rules_from_file(f)
+    assert len(rules) == 1
+
+
+def test_load_from_missing_file_raises():
+    with pytest.raises(RuleLoadError, match="not found"):
+        load_rules_from_file("/nonexistent/path/rules.json")
+
+
+def test_load_from_invalid_json_raises(tmp_path: Path):
+    f = tmp_path / "bad.json"
+    f.write_text("NOT JSON", encoding="utf-8")
+    with pytest.raises(RuleLoadError, match="invalid JSON"):
+        load_rules_from_file(f)
+
+
+def test_priority_ordering():
+    rules_data = [
+        {**VALID_RULE, "rule_id": "low", "priority": 1},
+        {**VALID_RULE, "rule_id": "high", "priority": 10},
+    ]
+    rules = load_rules_from_list(rules_data)
+    assert rules[0].rule_id == "high"
+    assert rules[1].rule_id == "low"