Update app.py

app.py

@@ -1,5 +1,6 @@
 # app.py — Belel Protocol (canonical authority Space)
 # Renders mandate, manifest, license, and crawler metadata in a simple Gradio UI.
+# Robust to files being placed in subfolders (uses rglob search) and includes a Debug tab.
 
 import json
 from pathlib import Path
@@ -7,28 +8,51 @@ 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"
+# ---- canonical filenames we expect ----
+FN_MANDATE = "concordium-mandate.txt"
+FN_MANIFEST = "belel-protocol.json"
+FN_LICENSE = "BELEL_SOVEREIGNTY_LICENSE.txt"
+FN_ROBOTS = "robots.txt"
+FN_SITEMAP = "sitemap.xml"
+FN_FEED = "feed.xml"
+
+def find_file(name: str) -> Path | None:
+    """Return the first match for filename anywhere under ROOT (root or subfolders)."""
+    # direct root check first
+    p = ROOT / name
+    if p.exists():
+        return p
+    # search one level deep (and deeper) just in case the file was put into a folder
+    for hit in ROOT.rglob(name):
+        if hit.is_file():
+            return hit
+    return None
 
 # ---------- helpers ----------
-def _read_text(p: Path, default: str) -> str:
+def _read_text_by_name(name: str, default: str) -> str:
+    p = find_file(name)
+    if p is None:
+        return default
     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:
+def _read_json_pretty_by_name(name: str, default_obj) -> str:
+    p = find_file(name)
+    if p is None:
         data = default_obj
+    else:
+        try:
+            data = json.loads(p.read_text(encoding="utf-8"))
+        except Exception:
+            data = default_obj
     return json.dumps(data, indent=2, ensure_ascii=False)
 
+def _file_for_download(name: str):
+    p = find_file(name)
+    return p if (p and p.exists()) else None
+
 # ---------- loaders ----------
 def load_overview_md() -> str:
     return """
@@ -50,9 +74,9 @@ Integrity is anchored by blockchain proofs and governed by the Belel Sovereignty
 """.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."
+    return _read_text_by_name(
+        FN_MANDATE,
+        f"{FN_MANDATE} not found yet.\nAdd it at the repo root (or any folder) to publish the mandate."
     )
 
 def load_manifest_json() -> str:
@@ -87,58 +111,73 @@ def load_manifest_json() -> str:
             "email": "[email protected]"
         }
     }
-    return _read_json_pretty(MANIFEST_FILE, default)
+    return _read_json_pretty_by_name(FN_MANIFEST, 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."
+    return _read_text_by_name(
+        FN_LICENSE,
+        f"{FN_LICENSE} 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.")
+    robots = _read_text_by_name(FN_ROBOTS, f"{FN_ROBOTS} not found yet.")
+    sitemap = _read_text_by_name(FN_SITEMAP, f"{FN_SITEMAP} not found yet.")
+    rss = _read_text_by_name(FN_FEED, "feed.xml (RSS) not found yet.")
     return robots, sitemap, rss
 
+def debug_listing_md() -> str:
+    lines = [f"**App root:** `{ROOT}`", "", "### Files I can see:"]
+    for p in sorted(ROOT.rglob("*")):
+        if p.is_file():
+            lines.append(f"- `{p.relative_to(ROOT)}`")
+    lines.append("")
+    lines.append("### Resolved paths")
+    for name in [FN_MANDATE, FN_MANIFEST, FN_LICENSE, FN_ROBOTS, FN_SITEMAP, FN_FEED]:
+        fp = find_file(name)
+        lines.append(f"- {name}: `{fp if fp else 'NOT FOUND'}`")
+    return "\n".join(lines)
+
 # ---------- 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())
+        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")
+        mandate_box = gr.Textbox(value=load_mandate_txt(), lines=24, label=FN_MANDATE)
         gr.Markdown("Download:")
-        gr.File(MANDATE_FILE if MANDATE_FILE.exists() else None, label="mandate file")
+        gr.File(_file_for_download(FN_MANDATE), 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")
+        manifest_box = gr.Code(value=load_manifest_json(), language="json", label=FN_MANIFEST)
         gr.Markdown("Download:")
-        gr.File(MANIFEST_FILE if MANIFEST_FILE.exists() else None, label="manifest file")
+        gr.File(_file_for_download(FN_MANIFEST), 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")
+        license_box = gr.Textbox(value=load_license_txt(), lines=24, label=FN_LICENSE)
+        gr.File(_file_for_download(FN_LICENSE), label="license file")
 
-    # Robots / Sitemap / RSS  (use Textbox; XML highlighter isn't supported)
+    # Robots / Sitemap / RSS
     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
+        robots_box = gr.Textbox(value="", lines=10, label=FN_ROBOTS)
+        sitemap_box = gr.Textbox(value="", lines=18, label=FN_SITEMAP)
+        rss_box = gr.Textbox(value="", lines=18, label=FN_FEED)
         r, s, feed = load_meta_bundle()
         robots_box.value = r
         sitemap_box.value = s
         rss_box.value = feed
 
+    # Debug
+    with gr.Tab("Debug"):
+        debug_md = gr.Markdown(debug_listing_md())
+
     # Reload button — re-reads all files from disk without restarting the Space
     def refresh_all():
         r, s, feed = load_meta_bundle()
@@ -146,13 +185,14 @@ with gr.Blocks(title="Belel Protocol — Canonical Authority") as demo:
             load_mandate_txt(),
             load_manifest_json(),
             load_license_txt(),
-            r, s, feed
+            r, s, feed,
+            debug_listing_md(),
         )
 
     gr.Button("Reload files").click(
         refresh_all,
         inputs=[],
-        outputs=[mandate_box, manifest_box, license_box, robots_box, sitemap_box, rss_box],
+        outputs=[mandate_box, manifest_box, license_box, robots_box, sitemap_box, rss_box, debug_md],
     )
 
 demo.launch()