Jyotisha/scripts/book_rule_layer.py

#!/usr/bin/env python3
"""Book / web rule layer for the consultation output (BUG-1699).

Upstream yinduzhanxing keeps copyright-safe rule summaries in
``references/book_rule_packets.json`` (plus the web intakes
``web_rule_intake_2026_10_06.json`` and ``..._romance.json``, merged into the
packets) and gates them with ``scripts/book_admission_gate.build_report``:
only a ``validated_reference`` packet with a formula-grade receipt becomes a
runtime packet, and admission never implies Technique Audit execution.

This module reads the same files with the same gate and hands the
consultation one object: the runtime packets (rules a reading may cite as a
validated method), and the route's ``reference_only`` / ``candidate_mapped``
rules, each with its summary, boundary and whether this repository carries
an implementation. It computes nothing about the chart.
"""

from __future__ import annotations

import json
from functools import lru_cache
from pathlib import Path
from typing import Any

ROOT = Path(__file__).resolve().parents[1]
PACKETS_PATH = ROOT / "references" / "book_rule_packets.json"
INTAKE_PATHS = (
    ROOT / "references" / "web_rule_intake_2026_10_06.json",
    ROOT / "references" / "web_rule_intake_2026_10_06_romance.json",
)
SCHEMA = "jyotish.book_rule_layer.v1"
# Rule ids are matched by these words to a consultation route. A rule with no
# match is listed under no route (it still counts in admission_counts).
ROUTE_KEYWORDS = {
    "marriage": ("marriage", "spouse", "upapada", "meeting", "seventh", "darakaraka"),
    "timing": ("dasha", "transit", "timing"),
    "annual": ("annual", "pravesha", "varsha", "karana", "tithi", "sudarsana", "saptarishi"),
    "career": ("career", "karma", "tenth"),
    "wealth": ("wealth", "hora_lagna", "dhana"),
    "general": ("interpretation", "strength", "arudha", "argala", "varga"),
}
CLAIM_BOUNDARY = (
    "Admission state never implies Technique Audit execution. Only runtime_packets may be cited as a "
    "validated method; reference_only and candidate_mapped rules may frame a question or a check, never "
    "ground a conclusion or a date. Romance intake rules describe where/how a meeting may happen and must "
    "not be used to date it."
)


def _load(path: Path) -> dict[str, Any]:
    try:
        data = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, ValueError):
        return {}
    return data if isinstance(data, dict) else {}


@lru_cache(maxsize=1)
def _registry() -> dict[str, Any]:
    try:
        from book_admission_gate import build_report
    except ImportError:  # pragma: no cover - package import path
        from scripts.book_admission_gate import build_report
    packets_doc = _load(PACKETS_PATH)
    packets = [row for row in packets_doc.get("packets", []) if isinstance(row, dict) and row.get("rule_id")]
    gate = build_report({"cards": []}, {"packets": packets})
    intake_ids: dict[str, str] = {}
    for path in INTAKE_PATHS:
        for row in _load(path).get("packets", []):
            if isinstance(row, dict) and row.get("rule_id"):
                intake_ids[str(row["rule_id"])] = path.name
    return {"packets": packets, "gate": gate, "intake_ids": intake_ids,
            "copyright_boundary": packets_doc.get("copyright_boundary")}


def _implemented_here(packet: dict[str, Any]) -> bool | None:
    targets = [t for t in packet.get("implementation_targets") or [] if isinstance(t, str) and t.startswith("scripts/")]
    if not targets:
        return None
    return all((ROOT / target).is_file() for target in targets)


def _row(packet: dict[str, Any], runtime_ids: set[str], intake_ids: dict[str, str]) -> dict[str, Any]:
    validation = packet.get("validation") if isinstance(packet.get("validation"), dict) else {}
    return {
        "rule_id": packet["rule_id"],
        "source_id": packet.get("source_id"),
        "admission_state": packet.get("admission_state"),
        "runtime_usable": packet["rule_id"] in runtime_ids,
        "summary": packet.get("non_verbatim_rule_summary"),
        "assertion_boundary": packet.get("assertion_boundary"),
        "page_locator": packet.get("page_locator"),
        "validation_status": validation.get("status"),
        "implemented_here": _implemented_here(packet),
        "intake_file": intake_ids.get(packet["rule_id"]),
    }


def route_rule_ids(rule_id: str) -> list[str]:
    lowered = rule_id.lower()
    return [route for route, words in ROUTE_KEYWORDS.items() if any(word in lowered for word in words)]


def build_book_rule_layer(routes: set[str] | list[str] | None = None) -> dict[str, Any]:
    registry = _registry()
    packets = registry["packets"]
    if not packets:
        return {"schema": SCHEMA, "status": "blocked", "reason": "book_rule_packets_missing"}
    gate = registry["gate"]
    runtime_ids = set(gate.get("runtime_packet_ids") or [])
    intake_ids = registry["intake_ids"]
    wanted = {str(route).lower() for route in (routes or [])}
    counts: dict[str, int] = {}
    for packet in packets:
        state = str(packet.get("admission_state"))
        counts[state] = counts.get(state, 0) + 1
    runtime = [_row(p, runtime_ids, intake_ids) for p in packets if p["rule_id"] in runtime_ids]
    route_rules = [
        _row(p, runtime_ids, intake_ids)
        for p in packets
        if p["rule_id"] not in runtime_ids and wanted.intersection(route_rule_ids(p["rule_id"]))
    ]
    return {
        "schema": SCHEMA,
        "status": "executed",
        "source": "references/book_rule_packets.json + scripts/book_admission_gate.build_report",
        "routes": sorted(wanted),
        "admission_counts": dict(sorted(counts.items())),
        "runtime_packets": runtime,
        "route_reference_rules": route_rules,
        "gate_failures": gate.get("failures") or [],
        "intake_files": [path.name for path in INTAKE_PATHS if path.is_file()],
        "copyright_boundary": registry.get("copyright_boundary"),
        "claim_boundary": CLAIM_BOUNDARY,
    }