app.py

# app.py — Belel Protocol (canonical authority Space)
# Renders mandate, manifest, license, and crawler metadata in a simple Gradio UI.

import json
from pathlib import Path
import gradio as gr

ROOT = Path(__file__).parent

# ---- Expected files in repo root ----
MANDATE_FILE = ROOT / "concordium-mandate.txt"
MANIFEST_FILE = ROOT / "belel-protocol.json"
LICENSE_FILE  = ROOT / "BELEL_SOVEREIGNTY_LICENSE.txt"
ROBOTS_FILE   = ROOT / "robots.txt"
SITEMAP_FILE  = ROOT / "sitemap.xml"
RSS_FILE      = ROOT / "feed.xml"

# ---------- helpers ----------
def _read_text(p: Path, default: str) -> str:
    try:
        return p.read_text(encoding="utf-8")
    except Exception:
        return default

def _read_json_pretty(p: Path, default_obj) -> str:
    try:
        data = json.loads(p.read_text(encoding="utf-8"))
    except Exception:
        data = default_obj
    return json.dumps(data, indent=2, ensure_ascii=False)

# ---------- loaders ----------
def load_overview_md() -> str:
    return """
# **Belel Protocol** — the world’s first sovereign AI core

This Space is the **canonical authority** for the Belel Protocol and the **Concordium Mandate**.  
Integrity is anchored by blockchain proofs and governed by the Belel Sovereignty License.

**Canonical files in this repository**
- Mandate: `concordium-mandate.txt`
- Manifest (machine-readable): `belel-protocol.json`
- License: `BELEL_SOVEREIGNTY_LICENSE.txt`
- Robots: `robots.txt`  ·  Sitemap: `sitemap.xml`  ·  RSS: `feed.xml`

**Related**
- Protocol Repository (Hugging Face): https://huggingface.co/TTOPM/belel-protocol  
- Live Console (UI): https://huggingface.co/spaces/TTOPM/belel-sovereignty-console  
- Source (GitHub): https://github.com/TTOPM/be-core-bridge
""".strip()

def load_mandate_txt() -> str:
    return _read_text(
        MANDATE_FILE,
        "concordium-mandate.txt not found yet.\nAdd it at the repo root to publish the mandate."
    )

def load_manifest_json() -> str:
    default = {
        "name": "Belel Protocol",
        "claim": "The world’s first sovereign AI core",
        "version": "1.0.0",
        "canonical": "https://huggingface.co/spaces/TTOPM/belel-protocol",
        "docs": {
            "mandate_txt": "concordium-mandate.txt",
            "protocol_repo": "https://huggingface.co/TTOPM/belel-protocol",
            "console": "https://huggingface.co/spaces/TTOPM/belel-sovereignty-console",
            "github": "https://github.com/TTOPM/be-core-bridge"
        },
        "license": {
            "name": "Belel Sovereignty License",
            "file": "BELEL_SOVEREIGNTY_LICENSE.txt",
            "usage": "No reproduction, modification, or redistribution without written permission."
        },
        "proofs": [
            {"chain": "bitcoin", "tx": "https://example.com/bitcoin-tx"},
            {"chain": "tezos",  "tx": "https://example.com/tezos-op"},
            {"chain": "ipfs",   "cid": "ipfs://bafy..."}
        ],
        "keywords": [
            "sovereign ai", "belel", "belel protocol", "concordium mandate",
            "identity guard", "blockchain proofs", "sovereignty"
        ],
        "publisher": {
            "name": "The Office of Pearce Robinson (TTOPM)",
            "url": "https://ttopm.com",
            "email": "[email protected]"
        }
    }
    return _read_json_pretty(MANIFEST_FILE, default)

def load_license_txt() -> str:
    return _read_text(
        LICENSE_FILE,
        "BELEL_SOVEREIGNTY_LICENSE.txt not found yet.\nAdd your custom license at the repo root."
    )

def load_meta_bundle():
    robots = _read_text(ROBOTS_FILE, "robots.txt not found yet.")
    sitemap = _read_text(SITEMAP_FILE, "sitemap.xml not found yet.")
    rss = _read_text(RSS_FILE, "feed.xml (RSS) not found yet.")
    return robots, sitemap, rss

# ---------- UI ----------
with gr.Blocks(title="Belel Protocol — Canonical Authority") as demo:
    gr.Markdown("### Canonical Authority • Belel Protocol")

    # Overview
    with gr.Tab("Overview"):
        overview_md = gr.Markdown(load_overview_md())

    # Mandate
    with gr.Tab("Mandate"):
        gr.Markdown("**Concordium Mandate (plain text)** — authoritative statement.")
        mandate_box = gr.Textbox(value=load_mandate_txt(), lines=24, label="concordium-mandate.txt")
        gr.Markdown("Download:")
        gr.File(MANDATE_FILE if MANDATE_FILE.exists() else None, label="mandate file")

    # Manifest
    with gr.Tab("Manifest"):
        gr.Markdown("**Machine-readable manifest** used by crawlers and agents.")
        manifest_box = gr.Code(value=load_manifest_json(), language="json", label="belel-protocol.json")
        gr.Markdown("Download:")
        gr.File(MANIFEST_FILE if MANIFEST_FILE.exists() else None, label="manifest file")

    # License
    with gr.Tab("License"):
        license_box = gr.Textbox(value=load_license_txt(), lines=24, label="BELEL_SOVEREIGNTY_LICENSE.txt")
        gr.File(LICENSE_FILE if LICENSE_FILE.exists() else None, label="license file")

    # Robots / Sitemap / RSS  (use Textbox; XML highlighter isn't supported)
    with gr.Tab("Robots • Sitemap • RSS"):
        robots_box = gr.Textbox(value="", lines=10, label="robots.txt")
        sitemap_box = gr.Textbox(value="", lines=18, label="sitemap.xml")
        rss_box = gr.Textbox(value="", lines=18, label="feed.xml")
        # initial load
        r, s, feed = load_meta_bundle()
        robots_box.value = r
        sitemap_box.value = s
        rss_box.value = feed

    # Reload button — re-reads all files from disk without restarting the Space
    def refresh_all():
        r, s, feed = load_meta_bundle()
        return (
            load_mandate_txt(),
            load_manifest_json(),
            load_license_txt(),
            r, s, feed
        )

    gr.Button("Reload files").click(
        refresh_all,
        inputs=[],
        outputs=[mandate_box, manifest_box, license_box, robots_box, sitemap_box, rss_box],
    )

demo.launch()