scripts/check_deployment_readiness.py

from __future__ import annotations

import argparse
import hashlib
import json
import re
from dataclasses import dataclass
from pathlib import Path
from typing import Literal


ROOT_DIR = Path(__file__).resolve().parent.parent
Status = Literal["PASS", "WARN", "FAIL"]
EXPORT_MANIFEST_NAME = ".export-manifest.json"


@dataclass
class Check:
    category: str
    name: str
    status: Status
    detail: str


def add(checks: list[Check], category: str, name: str, status: Status, detail: str) -> None:
    checks.append(Check(category, name, status, detail))


def load_json(path: Path) -> dict:
    try:
        return json.loads(path.read_text(encoding="utf-8"))
    except Exception:
        return {}


def dockerfile_copy_sources(dockerfile: str) -> list[str]:
    sources: list[str] = []
    for line in dockerfile.splitlines():
        line = line.strip()
        if not line.startswith("COPY "):
            continue
        parts = line.split()
        if len(parts) < 3:
            continue
        sources.extend(parts[1:-1])
    return sources


def referenced_scripts(dockerfile: str) -> set[str]:
    return set(re.findall(r"scripts/[A-Za-z0-9_.-]+\.sh", dockerfile))


def file_sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def should_manifest_copy(path: Path) -> bool:
    if path.name in {"__pycache__", ".pytest_cache", ".ruff_cache"}:
        return False
    if path.suffix in {".pyc", ".pyo", ".pyd"}:
        return False
    return True


def expected_export_manifest(root: Path | None = None) -> dict[str, str]:
    root = root or ROOT_DIR
    files: dict[str, str] = {}
    for relative in [
        "requirements.txt",
        "requirements-silma.txt",
        "requirements-supertonic.txt",
        "requirements-paddleocr.txt",
        "requirements-paddleocr-vl.txt",
        "requirements-qari-ocr.txt",
        "requirements-tawkeed-ocr.txt",
        "requirements-katib-ocr.txt",
        "requirements-arabic-qwen-ocr.txt",
        "requirements-arabic-glm-ocr.txt",
        "requirements-baseer-ocr.txt",
    ]:
        path = root / relative
        if path.exists():
            files[relative] = file_sha256(path)
    dockerfile = root / "Dockerfile.worker"
    if dockerfile.exists():
        files["Dockerfile"] = file_sha256(dockerfile)
    for relative in ["app", "api", "docs", "static", "scripts"]:
        base = root / relative
        if not base.exists():
            continue
        for path in sorted(base.rglob("*")):
            if path.is_file() and should_manifest_copy(path):
                files[path.relative_to(root).as_posix()] = file_sha256(path)
    return files


def check_required_files(root: Path = ROOT_DIR) -> list[Check]:
    checks: list[Check] = []
    required = [
        "app/main.py",
        "api/index.py",
        "static/index.html",
        "static/app.js",
        "static/styles.css",
        "requirements.txt",
        "vercel.json",
        "Dockerfile.worker",
        "requirements-silma.txt",
        "requirements-supertonic.txt",
        "requirements-paddleocr.txt",
        "requirements-paddleocr-vl.txt",
        "requirements-qari-ocr.txt",
        "requirements-tawkeed-ocr.txt",
        "requirements-katib-ocr.txt",
        "requirements-arabic-qwen-ocr.txt",
        "requirements-arabic-glm-ocr.txt",
        "requirements-baseer-ocr.txt",
        "scripts/setup_silma.sh",
        "scripts/setup_supertonic.sh",
        "scripts/setup_paddleocr.sh",
        "scripts/setup_paddleocr_vl.sh",
        "scripts/setup_qari_ocr.sh",
        "scripts/setup_tawkeed_ocr.sh",
        "scripts/setup_katib_ocr.sh",
        "scripts/setup_arabic_qwen_ocr.sh",
        "scripts/setup_arabic_glm_ocr.sh",
        "scripts/setup_baseer_ocr.sh",
        "scripts/qari_ocr_extract.py",
        "scripts/tawkeed_ocr_extract.py",
        "scripts/katib_ocr_extract.py",
        "scripts/arabic_qwen_ocr_extract.py",
        "scripts/arabic_glm_ocr_extract.py",
        "scripts/baseer_ocr_extract.py",
        "scripts/audit_goal_readiness.py",
        "scripts/prove_local_readiness.py",
        "scripts/prove_live_deployment.py",
        "scripts/configure_vercel_worker.py",
        "scripts/finish_live_deployment.py",
        "scripts/deployment_handoff.py",
        "scripts/prepare_live_deployment.py",
        "scripts/validate_deployment_env.py",
        "scripts/hosted_preflight.py",
        "scripts/verify_site.py",
        "scripts/verify_worker.py",
        "scripts/preflight_check.py",
        "scripts/check_research_sources.py",
        "scripts/research_watchlist.py",
        "scripts/refresh_research_evidence.py",
        "scripts/export_tts_sample.py",
        "scripts/export_ocr_sample_images.py",
        "scripts/score_voice_listening.py",
        "scripts/score_tts_preprocessor.py",
        "scripts/score_external_ocr.py",
        "scripts/model_promotion_gate.py",
        "scripts/next_deployment_step.py",
        "scripts/deployment_status.py",
        "scripts/check_test_environment.py",
        "docs/live-deployment-checklist.md",
        "docs/father-user-guide.md",
        "docs/source-evidence.md",
        "docs/huggingface-model-metadata.md",
        "docs/research-watchlist.md",
        "docs/recommended-free-stack.md",
        "docs/recommended-decision-card.md",
        "docs/recommended-decision-card.json",
    ]
    for relative in required:
        path = root / relative
        add(checks, "Files", relative, "PASS" if path.exists() else "FAIL", "exists" if path.exists() else "missing")
    return checks


def check_vercel(root: Path = ROOT_DIR) -> list[Check]:
    checks: list[Check] = []
    config_path = root / "vercel.json"
    config = load_json(config_path)
    add(checks, "Vercel", "config readable", "PASS" if config else "FAIL", str(config_path))
    if not config:
        return checks
    has_builds = "builds" in config
    has_functions = "functions" in config
    add(
        checks,
        "Vercel",
        "functions/builds conflict",
        "FAIL" if has_builds and has_functions else "PASS",
        "do not use builds and functions together" if has_builds and has_functions else "ok",
    )
    rewrites = config.get("rewrites") or []
    rewrite_ok = any(item.get("destination") == "/api/index.py" for item in rewrites if isinstance(item, dict))
    add(checks, "Vercel", "FastAPI rewrite", "PASS" if rewrite_ok else "FAIL", json.dumps(rewrites))
    functions = config.get("functions") or {}
    api_function = functions.get("api/index.py", {})
    max_duration = api_function.get("maxDuration", 0)
    add(
        checks,
        "Vercel",
        "function maxDuration",
        "PASS" if isinstance(max_duration, int) and max_duration >= 60 else "WARN",
        str(max_duration),
    )
    return checks


def check_worker(root: Path = ROOT_DIR) -> list[Check]:
    checks: list[Check] = []
    dockerfile_path = root / "Dockerfile.worker"
    if not dockerfile_path.exists():
        add(checks, "Worker", "Dockerfile.worker", "FAIL", "missing")
        return checks
    dockerfile = dockerfile_path.read_text(encoding="utf-8")
    add(checks, "Worker", "base image", "PASS" if "python:3.10" in dockerfile else "WARN", "Python 3.10 is expected")
    for package in ["tesseract-ocr-ara", "espeak-ng", "ffmpeg"]:
        add(checks, "Worker", f"apt package {package}", "PASS" if package in dockerfile else "FAIL", package)
    for env_key in ["WORK_DIR", "DATABASE_PATH", "OCR_ENGINE=tesseract", "OCR_RENDER_ZOOM=2", "TESSERACT_PSM=4", "AUDIO_FORMAT=mp3"]:
        add(checks, "Worker", f"env {env_key}", "PASS" if env_key in dockerfile else "WARN", env_key)
    for arg in [
        "ARG INSTALL_QARI_OCR=0",
        "ARG INSTALL_TAWKEED_OCR=0",
        "ARG INSTALL_KATIB_OCR=0",
        "ARG INSTALL_ARABIC_QWEN_OCR=0",
        "ARG INSTALL_ARABIC_GLM_OCR=0",
        "ARG INSTALL_BASEER_OCR=0",
        "ARG INSTALL_PADDLEOCR_VL=0",
        "ARG INSTALL_SUPERTONIC=0",
    ]:
        add(
            checks,
            "Worker",
            f"optional build {arg.split()[1]}",
            "PASS" if arg in dockerfile else "WARN",
            "lets stronger workers install heavy OCR sidecars",
        )
    optional_scripts = {
        "scripts/setup_supertonic.sh": "SUPERTONIC",
        "scripts/setup_qari_ocr.sh": "QARI_OCR",
        "scripts/setup_tawkeed_ocr.sh": "TAWKEED_OCR",
        "scripts/setup_katib_ocr.sh": "KATIB_OCR",
        "scripts/setup_arabic_qwen_ocr.sh": "ARABIC_QWEN_OCR",
        "scripts/setup_arabic_glm_ocr.sh": "ARABIC_GLM_OCR",
        "scripts/setup_baseer_ocr.sh": "BASEER_OCR",
        "scripts/setup_paddleocr_vl.sh": "PADDLEOCR_VL",
    }
    for optional_script, build_arg_name in optional_scripts.items():
        conditional_marker = f"if [ \"$INSTALL_{build_arg_name}\" = \"1\" ]"
        add(
            checks,
            "Worker",
            f"conditional {optional_script}",
            "PASS" if optional_script in dockerfile and conditional_marker in dockerfile else "WARN",
            "optional heavy OCR install is controlled by build arg",
        )
    for source in dockerfile_copy_sources(dockerfile):
        source_path = root / source
        add(
            checks,
            "Worker",
            f"COPY source {source}",
            "PASS" if source_path.exists() else "FAIL",
            "exists" if source_path.exists() else "missing",
        )
    for script in sorted(referenced_scripts(dockerfile)):
        script_path = root / script
        add(checks, "Worker", f"referenced {script}", "PASS" if script_path.exists() else "FAIL", "exists" if script_path.exists() else "missing")
    return checks


def check_ignore_files(root: Path = ROOT_DIR) -> list[Check]:
    checks: list[Check] = []
    gitignore = (root / ".gitignore").read_text(encoding="utf-8") if (root / ".gitignore").exists() else ""
    dockerignore = (root / ".dockerignore").read_text(encoding="utf-8") if (root / ".dockerignore").exists() else ""
    vercelignore = (root / ".vercelignore").read_text(encoding="utf-8") if (root / ".vercelignore").exists() else ""
    for name, content in [(".gitignore", gitignore), (".dockerignore", dockerignore), (".vercelignore", vercelignore)]:
        add(checks, "Ignore", name, "PASS" if content else "WARN", "present" if content else "missing")
        add(checks, "Ignore", f"{name} excludes .env", "PASS" if ".env" in content else "WARN", "secrets should not deploy")
        add(
            checks,
            "Ignore",
            f"{name} excludes outputs",
            "PASS" if any(line.strip().rstrip("/") == "outputs" for line in content.splitlines()) else "WARN",
            "generated handoffs/audio should not deploy or commit",
        )
    for required in ["app", "api", "static", "requirements.txt"]:
        excluded = any(line.strip() == required for line in vercelignore.splitlines())
        add(checks, "Ignore", f"Vercel keeps {required}", "FAIL" if excluded else "PASS", "not excluded" if not excluded else "excluded")
    return checks


def check_deployment_handoff(root: Path = ROOT_DIR) -> list[Check]:
    checks: list[Check] = []
    path = root / "scripts" / "deployment_handoff.py"
    text = path.read_text(encoding="utf-8", errors="replace") if path.exists() else ""
    markers = {
        "deployment prep command": "prepare_live_deployment.py",
        "Vercel CLI production deploy": "vercel --prod --yes",
        "Vercel worker env command": "vercel env add WORKER_BASE_URL production",
        "Hugging Face deploy helper": "deploy_hf_space.py",
        "Hugging Face Space bundle path": "outputs/huggingface-space",
        "deployment status command": "deployment_status.py --worker-url",
        "Vercel worker diagnostic command": "hosted_preflight.py",
        "Vercel worker CORS diagnostic": "site worker CORS ready",
        "live proof command": "prove_live_deployment.py",
        "worker verification report": "worker-verification.json",
        "copy paste secret block": "Copy/paste secret values",
        "copy paste build args": "Copy/paste balanced build args",
        "copy paste Vercel env": "Copy/paste Vercel values",
        "Vercel direct cloud fallback cleanup": "vercel env rm ENABLE_DIRECT_CLOUD_TTS production --yes",
        "Vercel Hugging Face token cleanup": "vercel env rm HF_API_TOKEN production --yes",
        "Vercel Hugging Face model cleanup": "vercel env rm HF_TTS_MODEL production --yes",
        "Vercel default voice cleanup": "vercel env rm DEFAULT_VOICE_ID production --yes",
    }
    for name, marker in markers.items():
        add(
            checks,
            "Handoff",
            name,
            "PASS" if marker in text else "FAIL",
            marker if marker in text else f"missing marker: {marker}",
        )
    return checks


def check_deployment_quickstart(root: Path = ROOT_DIR) -> list[Check]:
    checks: list[Check] = []
    path = root / "outputs" / "deployment-quickstart.md"
    if not path.exists():
        add(checks, "Quickstart", "deployment quickstart", "WARN", "run scripts/prepare_live_deployment.py")
        return checks
    text = path.read_text(encoding="utf-8", errors="replace")
    markers = {
        "Hugging Face new Space link": "https://huggingface.co/new-space",
        "Hugging Face Docker docs link": "https://huggingface.co/docs/hub/main/en/spaces-sdks-docker",
        "Vercel new project link": "https://vercel.com/new",
        "Vercel FastAPI docs link": "https://vercel.com/docs/frameworks/backend/fastapi",
        "handoff command": "deployment_handoff.py",
        "hosted preflight command": "hosted_preflight.py",
        "hosted preflight report": "hosted-preflight.json",
        "worker CORS ready reminder": "site worker CORS ready",
        "worker bundle path": "outputs\\huggingface-space",
        "final proof warning": "live-deployment-proof.json",
        "safety checklist": "Safety Checklist",
        "shared secret reminder": "same generated `SECRET_KEY`",
        "worker URL reminder": "`WORKER_BASE_URL` at the exact Hugging Face Space URL",
        "direct cloud fallback disabled": "direct Hugging Face TTS disabled",
        "temporary cloud variable cleanup": "ENABLE_DIRECT_CLOUD_TTS",
        "current next command": "Current Next Command",
    }
    for name, marker in markers.items():
        add(
            checks,
            "Quickstart",
            name,
            "PASS" if marker in text else "FAIL",
            marker if marker in text else f"missing marker: {marker}",
        )
    return checks


def check_env_validator(root: Path = ROOT_DIR) -> list[Check]:
    checks: list[Check] = []
    path = root / "scripts" / "validate_deployment_env.py"
    text = path.read_text(encoding="utf-8", errors="replace") if path.exists() else ""
    markers = {
        "validator rejects Vercel as worker URL": "WORKER_BASE_URL is not Vercel site",
        "validator prefers Hugging Face Space worker": "WORKER_BASE_URL uses free worker host",
        "validator rejects wildcard CORS": "CORS_ORIGINS has no wildcard",
        "validator rejects non-Vercel CORS origins": "CORS_ORIGINS are Vercel origins",
    }
    for name, marker in markers.items():
        add(
            checks,
            "Env validator",
            name,
            "PASS" if marker in text else "FAIL",
            marker if marker in text else f"missing marker: {marker}",
        )
    return checks


def check_app_contract(root: Path = ROOT_DIR) -> list[Check]:
    checks: list[Check] = []
    app_path = root / "app" / "main.py"
    static_path = root / "static" / "app.js"
    verify_site_path = root / "scripts" / "verify_site.py"
    audit_path = root / "scripts" / "audit_goal_readiness.py"
    app_text = app_path.read_text(encoding="utf-8", errors="replace") if app_path.exists() else ""
    static_text = static_path.read_text(encoding="utf-8", errors="replace") if static_path.exists() else ""
    verify_text = verify_site_path.read_text(encoding="utf-8", errors="replace") if verify_site_path.exists() else ""
    audit_text = audit_path.read_text(encoding="utf-8", errors="replace") if audit_path.exists() else ""
    markers = {
        "health exposes productionReady": (app_text, '"productionReady"'),
        "health exposes nextAction": (app_text, '"nextAction"'),
        "health blocks direct cloud fallback readiness": (app_text, "not direct_cloud_fallback"),
        "ui shows deployment next action": (static_text, "deploymentStatus.nextAction"),
        "ui warns when productionReady false": (static_text, "deploymentStatus.productionReady === false"),
        "site verifier checks productionReady": (verify_text, "site production worker ready"),
        "site verifier checks worker diagnostics": (verify_text, "site worker reachable from vercel"),
        "site verifier checks worker CORS": (verify_text, "site worker CORS ready"),
        "goal audit requires productionReady proof": (audit_text, "site production worker ready"),
        "goal audit requires worker diagnostics proof": (audit_text, "site worker reachable from vercel"),
        "goal audit requires worker CORS proof": (audit_text, "site worker CORS ready"),
    }
    for name, (text, marker) in markers.items():
        add(
            checks,
            "App contract",
            name,
            "PASS" if marker in text else "FAIL",
            marker if marker in text else f"missing marker: {marker}",
        )
    return checks


def check_hf_space_export(root: Path = ROOT_DIR) -> list[Check]:
    checks: list[Check] = []
    export_dir = root / "outputs" / "huggingface-space"
    if not export_dir.exists():
        add(checks, "HF Space", "export bundle", "WARN", "run scripts/export_hf_space.py --force")
        return checks
    required = [
        "Dockerfile",
        "README.md",
        ".dockerignore",
        EXPORT_MANIFEST_NAME,
        "requirements.txt",
        "requirements-silma.txt",
        "requirements-supertonic.txt",
        "requirements-paddleocr.txt",
        "requirements-paddleocr-vl.txt",
        "requirements-qari-ocr.txt",
        "requirements-tawkeed-ocr.txt",
        "requirements-katib-ocr.txt",
        "requirements-arabic-qwen-ocr.txt",
        "requirements-arabic-glm-ocr.txt",
        "requirements-baseer-ocr.txt",
        ".export-complete",
        "app/main.py",
        "api/index.py",
        "static/index.html",
        "scripts/setup_silma.sh",
        "scripts/setup_supertonic.sh",
        "scripts/setup_paddleocr.sh",
        "scripts/setup_paddleocr_vl.sh",
        "scripts/setup_qari_ocr.sh",
        "scripts/setup_tawkeed_ocr.sh",
        "scripts/setup_katib_ocr.sh",
        "scripts/setup_arabic_qwen_ocr.sh",
        "scripts/setup_arabic_glm_ocr.sh",
        "scripts/setup_baseer_ocr.sh",
        "scripts/qari_ocr_extract.py",
        "scripts/tawkeed_ocr_extract.py",
        "scripts/katib_ocr_extract.py",
        "scripts/arabic_qwen_ocr_extract.py",
        "scripts/arabic_glm_ocr_extract.py",
        "scripts/baseer_ocr_extract.py",
        "scripts/audit_goal_readiness.py",
        "scripts/prove_local_readiness.py",
        "scripts/prove_live_deployment.py",
        "scripts/deployment_handoff.py",
        "scripts/prepare_live_deployment.py",
        "scripts/validate_deployment_env.py",
        "scripts/verify_site.py",
        "scripts/check_research_sources.py",
        "scripts/research_watchlist.py",
        "scripts/refresh_research_evidence.py",
        "scripts/export_tts_sample.py",
        "scripts/export_ocr_sample_images.py",
        "scripts/score_voice_listening.py",
        "scripts/score_tts_preprocessor.py",
        "scripts/score_external_ocr.py",
        "scripts/model_promotion_gate.py",
        "scripts/next_deployment_step.py",
        "scripts/deployment_status.py",
        "docs/live-deployment-checklist.md",
        "docs/father-user-guide.md",
        "docs/source-evidence.md",
        "docs/huggingface-model-metadata.md",
        "docs/research-watchlist.md",
        "docs/recommended-free-stack.md",
        "docs/recommended-decision-card.md",
        "docs/recommended-decision-card.json",
    ]
    forbidden = [".env", "uploads", "outputs", "data", "test_pdfs", ".venv", ".venv-silma", ".venv-ocr"]
    for relative in required:
        path = export_dir / relative
        add(checks, "HF Space", f"bundle has {relative}", "PASS" if path.exists() else "FAIL", "exists" if path.exists() else "missing")
    manifest_path = export_dir / EXPORT_MANIFEST_NAME
    manifest = load_json(manifest_path)
    manifest_files = manifest.get("files") if isinstance(manifest, dict) else None
    expected_manifest = expected_export_manifest(root)
    if isinstance(manifest_files, dict):
        missing_manifest = sorted(path for path in expected_manifest if path not in manifest_files)
        changed_manifest = sorted(
            path for path, digest in expected_manifest.items() if manifest_files.get(path) != digest
        )
        extra_manifest = sorted(path for path in manifest_files if path not in expected_manifest)
        stale_detail = (
            f"missing={len(missing_manifest)} changed={len(changed_manifest)} extra={len(extra_manifest)}"
        )
        add(
            checks,
            "HF Space",
            "bundle manifest matches source",
            "PASS" if not missing_manifest and not changed_manifest else "FAIL",
            stale_detail,
        )
    else:
        add(checks, "HF Space", "bundle manifest matches source", "FAIL", "missing or invalid manifest")
    app_text = (export_dir / "app" / "main.py").read_text(encoding="utf-8", errors="replace") if (export_dir / "app" / "main.py").exists() else ""
    static_text = (
        (export_dir / "static" / "app.js").read_text(encoding="utf-8", errors="replace")
        if (export_dir / "static" / "app.js").exists()
        else ""
    )
    verify_site_text = (
        (export_dir / "scripts" / "verify_site.py").read_text(encoding="utf-8", errors="replace")
        if (export_dir / "scripts" / "verify_site.py").exists()
        else ""
    )
    qari_text = (
        (export_dir / "scripts" / "qari_ocr_extract.py").read_text(encoding="utf-8", errors="replace")
        if (export_dir / "scripts" / "qari_ocr_extract.py").exists()
        else ""
    )
    qari_default = "Qari-OCR-0.4.0-VL-4B-Instruct"
    tawkeed_text = (
        (export_dir / "scripts" / "tawkeed_ocr_extract.py").read_text(encoding="utf-8", errors="replace")
        if (export_dir / "scripts" / "tawkeed_ocr_extract.py").exists()
        else ""
    )
    tawkeed_default = "tawkeed-sa/tawkeed-ocr"
    katib_text = (
        (export_dir / "scripts" / "katib_ocr_extract.py").read_text(encoding="utf-8", errors="replace")
        if (export_dir / "scripts" / "katib_ocr_extract.py").exists()
        else ""
    )
    katib_default = "Katib-Qwen3.5-0.8B-0.1"
    arabic_qwen_text = (
        (export_dir / "scripts" / "arabic_qwen_ocr_extract.py").read_text(encoding="utf-8", errors="replace")
        if (export_dir / "scripts" / "arabic_qwen_ocr_extract.py").exists()
        else ""
    )
    arabic_qwen_requirements = (
        (export_dir / "requirements-arabic-qwen-ocr.txt").read_text(encoding="utf-8", errors="replace")
        if (export_dir / "requirements-arabic-qwen-ocr.txt").exists()
        else ""
    )
    arabic_qwen_default = "Arabic-Qwen3.5-OCR-v4"
    arabic_glm_text = (
        (export_dir / "scripts" / "arabic_glm_ocr_extract.py").read_text(encoding="utf-8", errors="replace")
        if (export_dir / "scripts" / "arabic_glm_ocr_extract.py").exists()
        else ""
    )
    arabic_glm_default = "Arabic-GLM-OCR-v2"
    baseer_text = (
        (export_dir / "scripts" / "baseer_ocr_extract.py").read_text(encoding="utf-8", errors="replace")
        if (export_dir / "scripts" / "baseer_ocr_extract.py").exists()
        else ""
    )
    baseer_default = "Baseer-OCR-V1.0"
    add(
        checks,
        "HF Space",
        "bundle uses QARI-OCR 0.4 default",
        "PASS" if qari_default in app_text and qari_default in qari_text else "FAIL",
        qari_default,
    )
    add(
        checks,
        "HF Space",
        "bundle uses Tawkeed Arabic OCR default",
        "PASS" if tawkeed_default in app_text and tawkeed_default in tawkeed_text else "FAIL",
        tawkeed_default,
    )
    add(
        checks,
        "HF Space",
        "bundle uses KATIB Arabic OCR default",
        "PASS" if katib_default in app_text and katib_default in katib_text else "FAIL",
        katib_default,
    )
    add(
        checks,
        "HF Space",
        "bundle uses Arabic-Qwen3.5 OCR default",
        "PASS" if arabic_qwen_default in app_text and arabic_qwen_default in arabic_qwen_text else "FAIL",
        arabic_qwen_default,
    )
    add(
        checks,
        "HF Space",
        "bundle has Arabic-Qwen3.5 model-specific runner",
        "PASS"
        if all(
            marker in arabic_qwen_text
            for marker in ["Qwen3_5ForConditionalGeneration", "process_vision_info", "trust_remote_code=True"]
        )
        and "qwen-vl-utils" in arabic_qwen_requirements
        else "FAIL",
        "Qwen3_5 loader plus qwen-vl-utils",
    )
    add(
        checks,
        "HF Space",
        "bundle uses Arabic-GLM OCR default",
        "PASS" if arabic_glm_default in app_text and arabic_glm_default in arabic_glm_text else "FAIL",
        arabic_glm_default,
    )
    add(
        checks,
        "HF Space",
        "bundle uses Baseer OCR default",
        "PASS" if baseer_default in app_text and baseer_default in baseer_text else "FAIL",
        baseer_default,
    )
    bundle_contract_markers = {
        "bundle health exposes productionReady": (app_text, '"productionReady"'),
        "bundle health exposes nextAction": (app_text, '"nextAction"'),
        "bundle health rejects direct cloud fallback readiness": (app_text, "not direct_cloud_fallback"),
        "bundle UI shows deployment next action": (static_text, "deploymentStatus.nextAction"),
        "bundle UI warns when productionReady false": (static_text, "deploymentStatus.productionReady === false"),
        "bundle verifier checks productionReady": (verify_site_text, "site production worker ready"),
        "bundle verifier checks worker diagnostics": (verify_site_text, "site worker reachable from vercel"),
        "bundle verifier checks worker CORS": (verify_site_text, "site worker CORS ready"),
    }
    for name, (text, marker) in bundle_contract_markers.items():
        add(
            checks,
            "HF Space",
            name,
            "PASS" if marker in text else "FAIL",
            marker if marker in text else f"missing marker: {marker}",
        )
    for relative in forbidden:
        path = export_dir / relative
        add(checks, "HF Space", f"bundle excludes {relative}", "PASS" if not path.exists() else "FAIL", "excluded" if not path.exists() else "present")
    return checks


def collect_checks(root: Path = ROOT_DIR) -> list[Check]:
    checks: list[Check] = []
    checks.extend(check_required_files(root))
    checks.extend(check_vercel(root))
    checks.extend(check_worker(root))
    checks.extend(check_ignore_files(root))
    checks.extend(check_deployment_handoff(root))
    checks.extend(check_deployment_quickstart(root))
    checks.extend(check_env_validator(root))
    checks.extend(check_app_contract(root))
    checks.extend(check_hf_space_export(root))
    return checks


def summarize(checks: list[Check]) -> dict[str, object]:
    counts = {"PASS": 0, "WARN": 0, "FAIL": 0}
    for check in checks:
        counts[check.status] += 1
    return {
        "ready": counts["FAIL"] == 0,
        "counts": counts,
        "checks": [check.__dict__ for check in checks],
    }


def print_table(checks: list[Check]) -> None:
    for check in checks:
        print(f"{check.status:<4}  {check.category:<8}  {check.name:<36}  {check.detail}")


def main() -> None:
    parser = argparse.ArgumentParser(description="Check Vercel and Docker worker deployment files before deploying.")
    parser.add_argument("--json", action="store_true", help="Print JSON instead of a compact table.")
    args = parser.parse_args()

    checks = collect_checks()
    if args.json:
        print(json.dumps(summarize(checks), indent=2))
    else:
        print_table(checks)
    if any(check.status == "FAIL" for check in checks):
        raise SystemExit(1)


if __name__ == "__main__":
    main()