@noeva/analytics-core 0.1.0 → 0.3.0

package/contenuto/lib/mcp-locale/server/modello_locale.py

@@ -0,0 +1,167 @@
+"""Da dove il servizio locale prende il modello (ADR 0005, punto 6).
+
+Il modello e' del cliente e sta nel repository del progetto; l'eseguibile e' di
+4D e cambia di rado. Per questo il modello non e' piu' cucito nell'eseguibile:
+all'avvio si cerca, in quest'ordine,
+
+1. nel repository, se Claude Code e' aperto li' (la cartella corrente o una sopra
+   ha analytics.json con questo progetto): si compila il modello del disco,
+   modifiche non committate comprese, cosi' chi sviluppa prova il modello che sta
+   scrivendo, prima del push;
+2. nell'ultima versione pubblicata sul contenitore (/_modello/<id>/corrente.json),
+   scaricata con la chiave API NOEVA dell'utente e tenuta in cache: una modifica
+   al modello arriva ai PC senza un rilascio di 4D;
+3. senza rete o senza contenitore, nell'ultima versione in cache;
+4. per ultimo nel modello della cartella consegnata, finche' le cartelle lo
+   portano ancora.
+
+La configurazione sta nella sorgente di noeva.json:
+
+    "modello_r2": {"progetto": "<id>", "url": "https://analytics.noeva.ai", "chiave_env": "NOEVA_API_KEY"}
+
+Senza `modello_r2` vale solo il punto 4, come prima. Niente qui stampa su stdout:
+e' il canale MCP.
+"""
+from __future__ import annotations
+
+import json
+import os
+import pathlib
+import shutil
+import sys
+import tempfile
+import urllib.error
+import urllib.parse
+import urllib.request
+
+# Cloudflare, davanti al contenitore, blocca lo user agent di urllib.
+AGENTE = "noeva-mcp-locale (NOEVA Analytics)"
+ATTESA_S = 15
+
+
+def log(msg: str) -> None:
+    print(f"noeva: {msg}", file=sys.stderr, flush=True)
+
+
+def cartella_cache(progetto: str) -> pathlib.Path:
+    """%LOCALAPPDATA%\\NOEVA\\modelli\\<id> su Windows, ~/.cache/noeva/modelli/<id> altrove."""
+    if os.environ.get("NOEVA_CACHE"):
+        base = pathlib.Path(os.environ["NOEVA_CACHE"])
+    elif os.environ.get("LOCALAPPDATA"):
+        base = pathlib.Path(os.environ["LOCALAPPDATA"]) / "NOEVA"
+    else:
+        base = pathlib.Path.home() / ".cache" / "noeva"
+    return base / "modelli" / progetto
+
+
+def repository_aperto(progetto: str, da: pathlib.Path | None = None) -> pathlib.Path | None:
+    """La radice del repository del progetto, se Claude Code e' aperto li' o sotto.
+
+    NOEVA_REPOSITORY la forza (per provare da un'altra cartella)."""
+    if os.environ.get("NOEVA_REPOSITORY"):
+        candidati = [pathlib.Path(os.environ["NOEVA_REPOSITORY"]).resolve()]
+    else:
+        d = (da or pathlib.Path.cwd()).resolve()
+        candidati = [d, *d.parents]
+    for c in candidati:
+        f = c / "analytics.json"
+        if not f.is_file():
+            continue
+        try:
+            if json.loads(f.read_text(encoding="utf-8")).get("progetto") == progetto and (c / "wren_project.yml").is_file():
+                return c
+        except (OSError, ValueError):
+            pass
+        return None  # il primo analytics.json trovato decide: e' un altro progetto
+    return None
+
+
+def compila_dal_repository(radice: pathlib.Path, cache: pathlib.Path) -> pathlib.Path:
+    from consegna import compila, leggi_consegna, modello_di_consegna
+
+    dest = cache / "repository"
+    if dest.exists():
+        shutil.rmtree(dest)
+    modello_di_consegna(radice, dest, leggi_consegna(radice))
+    compila(dest)
+    return dest
+
+
+def chiedi(url: str, chiave: str) -> bytes:
+    r = urllib.request.Request(url, headers={"Authorization": f"Bearer {chiave}", "User-Agent": AGENTE})
+    with urllib.request.urlopen(r, timeout=ATTESA_S) as risposta:
+        return risposta.read()
+
+
+def scarica(conf: dict, chiave: str, cache: pathlib.Path) -> tuple[pathlib.Path, str]:
+    """L'ultima versione pubblicata, dalla cache se c'e' gia' tutta. Solleva se il
+    contenitore non risponde o rifiuta: chi chiama ricade sulla cache."""
+    base = f"{conf['url'].rstrip('/')}/_modello/{conf['progetto']}"
+    corrente = json.loads(chiedi(f"{base}/corrente.json", chiave))
+    versione = corrente["versione"]
+    dest = cache / "versioni" / versione
+    if (dest / ".completa").is_file():
+        return dest, versione
+    # Si scarica accanto e si sposta alla fine: una versione a meta' (rete caduta)
+    # non diventa mai quella da usare.
+    (cache / "versioni").mkdir(parents=True, exist_ok=True)
+    tmp = pathlib.Path(tempfile.mkdtemp(prefix=f".{versione}-", dir=cache / "versioni"))
+    try:
+        for rel in corrente["file"]:
+            p = tmp / rel
+            if ".." in pathlib.PurePosixPath(rel).parts:
+                raise ValueError(f"percorso non ammesso nel modello pubblicato: {rel}")
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_bytes(chiedi(f"{base}/{versione}/{urllib.parse.quote(rel)}", chiave))
+        (tmp / ".completa").write_text(json.dumps({"versione": versione, "pubblicata": corrente.get("pubblicata")}),
+                                       encoding="utf-8")
+        if dest.exists():
+            shutil.rmtree(dest)
+        tmp.rename(dest)
+    finally:
+        if tmp.exists():
+            shutil.rmtree(tmp, ignore_errors=True)
+    return dest, versione
+
+
+def ultima_in_cache(cache: pathlib.Path) -> tuple[pathlib.Path, str] | None:
+    complete = [p.parent for p in (cache / "versioni").glob("*/.completa")]
+    if not complete:
+        return None
+    p = max(complete, key=lambda d: (d / ".completa").stat().st_mtime)
+    return p, p.name
+
+
+def trova(s: dict, consegnata: pathlib.Path) -> tuple[pathlib.Path, str]:
+    """La cartella del modello (con target/mdl.json) e da dove viene, in parole."""
+    conf = s.get("modello_r2")
+    if not conf:
+        return consegnata, "il modello della cartella consegnata"
+    progetto = conf["progetto"]
+    cache = cartella_cache(progetto)
+
+    repo = repository_aperto(progetto)
+    if repo:
+        try:
+            return compila_dal_repository(repo, cache), f"il repository aperto ({repo}), compilato all'avvio"
+        except Exception as e:  # noqa: BLE001 - un modello rotto nel repository non deve spegnere il servizio
+            log(f"il modello del repository {repo} non si compila ({e}): uso quello pubblicato")
+
+    chiave = os.environ.get(conf.get("chiave_env") or "NOEVA_API_KEY") or ""
+    if chiave.startswith("${"):
+        chiave = ""  # .mcp.json con "${VAR}" e la variabile assente
+    if chiave:
+        try:
+            dest, versione = scarica(conf, chiave, cache)
+            return dest, f"la versione pubblicata {versione} ({conf['url']})"
+        except urllib.error.HTTPError as e:
+            log(f"il contenitore rifiuta il modello di {progetto}: HTTP {e.code} {e.read()[:200].decode(errors='replace')}")
+        except Exception as e:  # noqa: BLE001 - rete, DNS, timeout: si ricade sulla cache
+            log(f"il contenitore non risponde ({e}): uso il modello in cache")
+    else:
+        log(f"manca la chiave API NOEVA nella variabile {conf.get('chiave_env') or 'NOEVA_API_KEY'}: niente aggiornamenti del modello")
+
+    in_cache = ultima_in_cache(cache)
+    if in_cache:
+        return in_cache[0], f"la versione {in_cache[1]} in cache (non aggiornata a questo avvio)"
+    return consegnata, "il modello della cartella consegnata (nessuna versione pubblicata raggiungibile)"

package/contenuto/lib/mcp-locale/server/noeva_mcp.py

@@ -0,0 +1,203 @@
+"""Il server MCP di un progetto NOEVA Analytics sul PC del cliente, senza Docker e senza Python.
+
+Si consegna come eseguibile (PyInstaller, `noeva-<progetto>.exe`) dentro la
+cartella di lavoro che il cliente apre con Claude Code: `.mcp.json` lo avvia da
+solo, una volta per sorgente (docs/spike-mcpb-windows.md). Gira anche da
+sorgente con Python, ed e' quello che fa l'estensione Claude Desktop (.mcpb).
+
+E' lo stesso server di `wren serve mcp` (gli stessi strumenti, lo stesso motore
+in processo), costruito qui invece che dalla CLI perche' sul PC del cliente non
+ci sono ~/.wren/profiles.yml ne' il repository: la configurazione sta in
+noeva.json accanto all'eseguibile, le password in variabili d'ambiente
+dell'utente Windows, e il server si presenta col nome NOEVA (ADR 0001).
+
+Una sorgente e' un database del cliente con il suo pezzo di modello (per esempio
+erp e dwh, ognuna col suo server, database, utente), oppure lo snapshot delle
+dashboard su DuckDB come ripiego offline.
+
+    noeva-<id> --sorgente erp       serve MCP su stdio (lo lancia Claude Code)
+    noeva-<id> --verifica           controlla driver, password e connessione di
+                                    tutte le sorgenti e dice cosa manca: si lancia
+                                    a mano dal PowerShell quando /mcp dice "failed"
+
+Su stdio lo stdout e' il canale del protocollo: fuori da --verifica qui non si
+stampa niente, i log vanno su stderr.
+"""
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import os
+import pathlib
+import sys
+
+# Congelato da PyInstaller la cartella e' quella dell'eseguibile; da sorgente,
+# quella sopra server/. NOEVA_DIR la forza (per provare da un'altra macchina).
+if os.environ.get("NOEVA_DIR"):
+    QUI = pathlib.Path(os.environ["NOEVA_DIR"]).resolve()
+elif getattr(sys, "frozen", False):
+    QUI = pathlib.Path(sys.executable).resolve().parent
+else:
+    QUI = pathlib.Path(__file__).resolve().parent.parent
+
+
+# Da sorgente, i moduli accanto (modello_locale) e lib/modello (consegna): congelato,
+# PyInstaller li ha gia' dentro (costruisci.py, --paths).
+if not getattr(sys, "frozen", False):
+    sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
+    sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[2] / "modello"))
+
+
+class Problema(Exception):
+    """Un errore di configurazione da spiegare a chi installa, non uno stack."""
+
+
+def configurazione() -> dict:
+    p = QUI / "noeva.json"
+    if not p.is_file():
+        raise Problema(f"manca {p}: la cartella di NOEVA e' incompleta")
+    return json.loads(p.read_text(encoding="utf-8"))
+
+
+def connessione_mssql(s: dict) -> dict:
+    env = os.environ
+    utente = s.get("utente") or ""
+    var = s.get("password_env") or ""
+    password = env.get(var) if var else None
+    if password and password.startswith("${"):
+        # .mcp.json con "${VAR}" e la variabile assente: Claude Code passa il
+        # testo cosi' com'e'. Meglio dirlo che tentare il login con quello.
+        password = None
+    if utente and not password:
+        raise Problema(
+            f"manca la password di {utente}: va nella variabile d'ambiente {var} dell'utente "
+            f"Windows (imposta-password.ps1), poi si chiude e si riapre Claude Code"
+        )
+    try:
+        import pyodbc
+    except ImportError as e:
+        # Su Windows pyodbc usa odbc32.dll, che c'e' sempre; su macOS/Linux
+        # vuole unixODBC (libodbc), e l'import fallisce qui se manca.
+        raise Problema(f"pyodbc non utilizzabile ({e})") from e
+    driver = env.get("NOEVA_MSSQL_DRIVER") or s.get("driver") or "ODBC Driver 18 for SQL Server"
+    if driver not in pyodbc.drivers():
+        raise Problema(
+            f"il driver '{driver}' non e' installato su questo PC "
+            f"(driver ODBC presenti: {', '.join(pyodbc.drivers()) or 'nessuno'})"
+        )
+    return {
+        "host": s["host"],
+        "port": str(s.get("porta") or "1433"),
+        "database": s["database"],
+        # Utente e password entrambi assenti: il connettore usa
+        # Trusted_Connection=yes, cioe' l'utente Windows.
+        "user": utente or None,
+        "password": password or None,
+        "driver": driver,
+        "kwargs": {"TrustServerCertificate": "yes", **(s.get("opzioni") or {})},
+    }
+
+
+def motore(s: dict):
+    from wren.engine import WrenEngine
+
+    import modello_locale
+
+    # Il modello non sta piu' solo nella cartella: repository aperto, versione
+    # pubblicata, cache (modello_locale.py, ADR 0005 punto 6).
+    progetto, origine = modello_locale.trova(s, (QUI / s["progetto"]).resolve())
+    s["_origine_modello"] = origine
+    modello_locale.log(f"{s['server']}: modello da {origine}")
+    mdl = progetto / "target" / "mdl.json"
+    if not mdl.is_file():
+        raise Problema(f"manca {mdl}: la cartella di NOEVA e' incompleta")
+    manifest = base64.b64encode(mdl.read_bytes()).decode()
+    if s["tipo"] == "duckdb":
+        dati = (QUI / s["dati"]).resolve()
+        if not any(dati.glob("*.duckdb")):
+            raise Problema(f"nessun .duckdb in {dati}")
+        # Il connettore DuckDB attacca in sola lettura ogni .duckdb della
+        # cartella, con alias = nome del file: e' il catalogo del modello.
+        eng = WrenEngine(manifest_str=manifest, data_source="duckdb",
+                         connection_info={"url": str(dati), "format": "duckdb"})
+    else:
+        eng = WrenEngine(manifest_str=manifest, data_source="mssql", connection_info=connessione_mssql(s))
+    return progetto, eng
+
+
+def servi(conf: dict, nome: str) -> None:
+    s = conf["sorgenti"][nome]
+    progetto, eng = motore(s)
+    from wren.mcp_server import ServeContext, build_server
+
+    server = build_server(ServeContext(project=progetto, engine=eng, allow_write=False, no_connect=False))
+    # FastMCP non espone un setter: nome e istruzioni stanno sul server di basso
+    # livello, ed e' quello che il client legge all'initialize.
+    server._mcp_server.name = s["server"]
+    server._mcp_server.instructions = s["istruzioni"]
+    try:
+        server.run(transport="stdio")
+    finally:
+        eng.close()
+
+
+def verifica(conf: dict, nomi: list[str]) -> int:
+    """Controlli leggibili da chi installa: cosa c'e', cosa manca, cosa fare."""
+    print(f"{conf['nome']} · {QUI}")
+    falliti = 0
+    for nome in nomi:
+        s = conf["sorgenti"][nome]
+        print(f"\n{s['server']} ({nome}: {s.get('cosa', '')})")
+        try:
+            progetto, eng = motore(s)
+        except Problema as e:
+            print(f"  NO  {e}")
+            falliti += 1
+            continue
+        print(f"  ..  modello: {s.get('_origine_modello')}")
+        if s["tipo"] == "mssql":
+            c = eng.connection_info
+            print(f"  ok  driver {c.driver}")
+            print(f"  ..  server {c.host},{c.port} · database {c.database} · "
+                  f"{'utente ' + c.user if c.user else 'autenticazione di Windows'}")
+        for titolo, sql in (s.get("verifiche") or {}).items():
+            try:
+                t = eng.query(sql, limit=5)
+                print(f"  ok  {titolo}: {t.to_pylist()[0] if t.num_rows else 'nessuna riga'}")
+            except Exception as e:  # noqa: BLE001 - qui si mostra l'errore, qualunque sia
+                print(f"  NO  {titolo}: {str(e).strip().splitlines()[0][:400]}")
+                falliti += 1
+                break
+        eng.close()
+    print("\ntutto a posto" if not falliti else f"\n{falliti} sorgente/i con problemi")
+    return 1 if falliti else 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(prog=pathlib.Path(sys.argv[0]).stem)
+    ap.add_argument("--sorgente", help="quale database servire (default: la prima di noeva.json)")
+    ap.add_argument("--verifica", action="store_true",
+                    help="controlla configurazione e connessione (tutte le sorgenti, o quella data), poi esce")
+    a = ap.parse_args(argv)
+    try:
+        conf = configurazione()
+        nomi = list(conf["sorgenti"])
+        if a.sorgente and a.sorgente not in nomi:
+            raise Problema(f"sorgente '{a.sorgente}' non prevista: {', '.join(nomi)}")
+        if a.verifica:
+            # In una pipe (lo script PowerShell, o Claude Code che lo lancia) la
+            # console di Windows non e' UTF-8: meglio un ? che un'eccezione.
+            sys.stdout.reconfigure(errors="replace")
+            return verifica(conf, [a.sorgente] if a.sorgente else nomi)
+        servi(conf, a.sorgente or nomi[0])
+    except Problema as e:
+        # Claude Code mostra il server come "failed" e questo messaggio nel log
+        # dell'MCP; --verifica lo ripete in chiaro.
+        print(f"noeva: {e}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/contenuto/lib/modello/consegna.py

@@ -0,0 +1,134 @@
+"""Il modello di consegna di un progetto: quello che il servizio locale serve sui PC del cliente.
+
+Il modello del repository e' costruito sui restore locali: la SQL dei modelli ERP
+nomina <db>.dbo.<tabella>, i modelli DWH non hanno catalogo e lo prendevano dal
+profilo. Qui le due cose diventano esplicite (`rinomina`, `catalogo_senza_nome`),
+cosi' un login solo sul server del cliente legge entrambi i database; e della
+conoscenza resta quella che il server serve.
+
+Lo usano in tre (ADR 0005, punto 6), e per questo sta in un modulo solo:
+
+- lib/mcp-locale/costruisci.py, che fino a oggi metteva il modello nella cartella
+  consegnata, con le trasformazioni di lib/mcp-locale/<id>.yml;
+- lib/modello/pubblica.py, che dal repository del progetto lo compila e lo
+  pubblica su R2, con le trasformazioni di `consegna.yml` del repository;
+- il servizio locale (lib/mcp-locale/server/noeva_mcp.py), che quando Claude Code
+  e' aperto nel repository compila il modello che sta li', non quello pubblicato.
+
+Le trasformazioni:
+
+    rinomina: {erp_restore: erp_prod}     <db>.dbo. nella SQL dei modelli
+    catalogo_senza_nome: dwh_prod         il catalogo dei modelli che non ne hanno
+    modelli: [vendite, ...]               solo questi (default: tutti)
+    query_esempio: true                   knowledge/sql si consegna (default: si')
+"""
+from __future__ import annotations
+
+import json
+import pathlib
+import shutil
+
+import yaml
+
+# Cosa del repository fa parte del modello: il resto (apps/, scripts/, docs/) no.
+FILE_MODELLO = ["wren_project.yml", "relationships.yml", "models", "knowledge"]
+# Le chiavi delle trasformazioni: il resto della configurazione di consegna
+# (la connessione senza password, le verifiche, il ripiego offline) serve ai
+# costruttori degli eseguibili, non al modello.
+CHIAVI = ("rinomina", "catalogo_senza_nome", "modelli", "query_esempio")
+
+
+def dump_yaml(dati, path: pathlib.Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(yaml.safe_dump(dati, allow_unicode=True, sort_keys=False, width=100), encoding="utf-8")
+
+
+def leggi_config(radice: pathlib.Path) -> dict:
+    """consegna.yml del repository del progetto, intero, o {} se non c'e'.
+
+    E' lo schema di lib/mcp-locale/<id>.yml del monorepo: cliente, domanda_prova,
+    modello_r2, sorgenti (una connessione e le sue trasformazioni ciascuna),
+    snapshot. Nessun segreto: le password stanno in variabili d'ambiente."""
+    f = radice / "consegna.yml"
+    return (yaml.safe_load(f.read_text(encoding="utf-8")) or {}) if f.is_file() else {}
+
+
+def trasformazioni(conf: dict) -> dict:
+    """Le trasformazioni del modello pubblicato: quelle della sorgente viva.
+
+    Un progetto pubblica un modello solo; con piu' sorgenti vive (un modello per
+    database) il modello pubblicato non saprebbe quale scegliere."""
+    vive = conf.get("sorgenti") or {}
+    if len(vive) > 1:
+        raise ValueError(f"consegna.yml: {len(vive)} sorgenti vive; il modello pubblicato ne vuole una")
+    s = next(iter(vive.values()), conf)
+    return {k: s[k] for k in CHIAVI if k in s}
+
+
+def leggi_consegna(radice: pathlib.Path) -> dict:
+    """Le trasformazioni di consegna.yml del repository, o {} (nessuna)."""
+    return trasformazioni(leggi_config(radice))
+
+
+def modello_di_consegna(sorgente: pathlib.Path, dest: pathlib.Path, conf: dict) -> dict:
+    """Scrive in `dest` il modello di `sorgente` con le trasformazioni di `conf`.
+
+    Restituisce i conteggi delle trasformazioni, che chi costruisce stampa."""
+    rinomina = conf.get("rinomina") or {}
+    senza_nome = conf.get("catalogo_senza_nome")
+    scelti = set(conf.get("modelli") or [])  # vuoto: tutti
+    conta = {"rinominati": 0, "catalogo": 0}
+    dest.mkdir(parents=True)
+    progetto = yaml.safe_load((sorgente / "wren_project.yml").read_text(encoding="utf-8"))
+    progetto.pop("profile", None)  # niente profili sul PC del cliente: noeva.json
+    dump_yaml(progetto, dest / "wren_project.yml")
+    relazioni = yaml.safe_load((sorgente / "relationships.yml").read_text(encoding="utf-8")) or {}
+    if scelti:
+        relazioni["relationships"] = [r for r in relazioni.get("relationships") or []
+                                      if set(r["models"]) <= scelti]
+    dump_yaml(relazioni, dest / "relationships.yml")
+    for meta in sorted((sorgente / "models").glob("*/metadata.yml")):
+        if scelti and meta.parent.name not in scelti:
+            continue
+        m = yaml.safe_load(meta.read_text(encoding="utf-8"))
+        for vecchio, nuovo in rinomina.items():
+            if m.get("ref_sql") and f"{vecchio}.dbo." in m["ref_sql"]:
+                conta["rinominati"] += m["ref_sql"].count(f"{vecchio}.dbo.")
+                m["ref_sql"] = m["ref_sql"].replace(f"{vecchio}.dbo.", f"{nuovo}.dbo.")
+        tr = m.get("table_reference")
+        if tr is not None and not tr.get("catalog") and senza_nome:
+            tr["catalog"] = senza_nome
+            conta["catalogo"] += 1
+        dump_yaml(m, dest / "models" / meta.parent.name / "metadata.yml")
+        for extra in meta.parent.glob("*.sql"):
+            testo = extra.read_text(encoding="utf-8")
+            for vecchio, nuovo in rinomina.items():
+                testo = testo.replace(f"{vecchio}.dbo.", f"{nuovo}.dbo.")
+            (dest / "models" / meta.parent.name / extra.name).write_text(testo, encoding="utf-8")
+    # La conoscenza che il server serve (regole, query d'esempio, glossario).
+    # Restano fuori domande.yml e risposte-cliente.json: sono il lavoro in corso
+    # col cliente, che legge la pagina «Il progetto».
+    k = sorgente / "knowledge"
+    (dest / "knowledge").mkdir()
+    if (k / "knowledge.yml").is_file():
+        shutil.copy2(k / "knowledge.yml", dest / "knowledge" / "knowledge.yml")
+    cartelle = ["rules", "glossary", "caveats", "metrics"]
+    if conf.get("query_esempio", True):
+        cartelle.append("sql")
+    for cartella in cartelle:
+        if (k / cartella).is_dir():
+            shutil.copytree(k / cartella, dest / "knowledge" / cartella,
+                            ignore=shutil.ignore_patterns(".gitkeep"))
+    return conta
+
+
+def compila(dest: pathlib.Path) -> pathlib.Path:
+    """target/mdl.json del modello in `dest`, come `wren context build`, nel processo:
+    il servizio locale congelato non ha la CLI wren, ha il pacchetto."""
+    from wren.context import build_json, save_target
+
+    return save_target(build_json(dest), dest)
+
+
+def numero_modelli(dest: pathlib.Path) -> int:
+    return len(json.loads((dest / "target" / "mdl.json").read_text(encoding="utf-8")).get("models") or [])

package/contenuto/lib/modello/pubblica.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Il modello di consegna di un progetto, compilato e pubblicato su R2 (ADR 0005, punto 6).
+
+    python3 lib/modello/pubblica.py <repository> --url http://localhost:8789 [--workspace <id>] [--prova]
+    npx analytics modello --url ...      (lo stesso, dal repository del progetto)
+
+Fa, in quest'ordine:
+
+1. prende il modello dal commit (HEAD), non dal disco: wren_project.yml,
+   relationships.yml, models/, knowledge/ e consegna.yml. Quello che va ai PC
+   del cliente e' quello che e' in git;
+2. applica le trasformazioni di `consegna.yml` del repository (consegna.py);
+3. compila target/mdl.json come `wren context build`;
+4. carica i file su /_modello/<id>/<versione>/ e sposta il puntatore, con un
+   biglietto di tipo `modello`.
+
+Il biglietto lo firma chi pubblica col segreto del contenitore (SEGRETO_DATI o
+~/.segreto-dati), o lo rilascia l'API NOEVA a chi ha la chiave di un membro del
+workspace (NOEVA_API_KEY o ~/.noeva-api-key): e' la strada della CI.
+
+La versione e' data e ora del commit piu' lo sha, come per le pagine: si legge
+da quale commit viene il modello che un PC usa.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import importlib.util
+import json
+import os
+import pathlib
+import subprocess
+import sys
+import tarfile
+import tempfile
+import time
+
+QUI = pathlib.Path(__file__).resolve().parent
+sys.path.insert(0, str(QUI))
+
+from consegna import FILE_MODELLO, compila, leggi_consegna, modello_di_consegna, numero_modelli  # noqa: E402
+
+# Il biglietto e le chiamate sono quelli dello snapshot (lib/snapshot/pubblica.py).
+# Si carica per percorso: si chiama pubblica.py anche lui, e un import per nome
+# troverebbe questo file.
+_spec = importlib.util.spec_from_file_location("snapshot_pubblica", QUI.parent / "snapshot" / "pubblica.py")
+_snapshot = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_snapshot)
+chiama, sorgente_biglietti = _snapshot.chiama, _snapshot.sorgente_biglietti
+
+
+def git(radice: pathlib.Path, *args: str) -> str:
+    return subprocess.run(["git", *args], cwd=radice, check=True, capture_output=True, text=True).stdout
+
+
+def versione_di(radice: pathlib.Path) -> str:
+    sha, quando = git(radice, "log", "-1", "--format=%h%x09%cI").strip().split("\t")
+    t = dt.datetime.fromisoformat(quando).astimezone(dt.timezone.utc)
+    return f"{t:%Y%m%d-%H%M%S}-{sha}"
+
+
+def estrai_da_head(radice: pathlib.Path, dest: pathlib.Path) -> None:
+    """I file del modello com'erano nel commit, senza toccare il disco del repository."""
+    presenti = [p for p in [*FILE_MODELLO, "consegna.yml"] if git(radice, "ls-tree", "--name-only", "HEAD", p).strip()]
+    mancanti = {"wren_project.yml", "relationships.yml", "models"} - set(presenti)
+    if mancanti:
+        raise SystemExit(f"nel commit mancano {sorted(mancanti)}: non e' il repository di un progetto con un modello")
+    archivio = subprocess.run(["git", "archive", "--format=tar", "HEAD", *presenti], cwd=radice,
+                              check=True, capture_output=True).stdout
+    with tempfile.TemporaryFile() as t:
+        t.write(archivio)
+        t.seek(0)
+        with tarfile.open(fileobj=t) as tar:
+            tar.extractall(dest, filter="data")
+
+
+def file_della_versione(dest: pathlib.Path) -> list[pathlib.Path]:
+    return sorted(p for p in dest.rglob("*") if p.is_file() and not p.name.startswith("."))
+
+
+def main(argv: list[str]) -> int:
+    ap = argparse.ArgumentParser(prog="analytics modello", description=__doc__.split("\n\n")[0])
+    ap.add_argument("repository", nargs="?", default=".", help="il repository del progetto (default: qui)")
+    ap.add_argument("--url", default=os.environ.get("NOEVA_ANALYTICS_URL"), help="il contenitore")
+    ap.add_argument("--workspace", help="il workspace NOEVA che possiede il progetto (default: analytics.json)")
+    ap.add_argument("--prova", action="store_true", help="compila ed elenca, senza caricare")
+    a = ap.parse_args(argv[1:])
+
+    radice = pathlib.Path(a.repository).resolve()
+    analytics = json.loads((radice / "analytics.json").read_text(encoding="utf-8"))
+    progetto = analytics["progetto"]
+    workspace = a.workspace or analytics.get("workspace")
+    versione = versione_di(radice)
+
+    with tempfile.TemporaryDirectory() as tmp:
+        sorgente, dest = pathlib.Path(tmp) / "sorgente", pathlib.Path(tmp) / "modello"
+        estrai_da_head(radice, sorgente)
+        # Le trasformazioni di consegna.yml anche loro dal commit, non dal disco.
+        conta = modello_di_consegna(sorgente, dest, leggi_consegna(sorgente))
+        compila(dest)
+        file = file_della_versione(dest)
+        byte = sum(p.stat().st_size for p in file)
+        print(f"▸ {progetto}: modello {versione}, {numero_modelli(dest)} modelli, {len(file)} file, "
+              f"{byte // 1024} kB ({conta['rinominati']} riferimenti rinominati, {conta['catalogo']} col catalogo)")
+        if a.prova:
+            print("prova: niente caricato")
+            return 0
+        if not a.url:
+            raise SystemExit("serve --url: l'indirizzo del contenitore (in prova http://localhost:8789)")
+        if not workspace:
+            raise SystemExit("serve il workspace NOEVA che possiede il progetto: `workspace` in analytics.json, o --workspace")
+        # Il biglietto: col segreto del contenitore se c'e' (il Mac di chi amministra),
+        # altrimenti dall'API NOEVA con la chiave di un membro del workspace (la CI).
+        da = f"ci {os.environ.get('GITHUB_REPOSITORY', '')}".strip() if os.environ.get("GITHUB_ACTIONS") else "analytics modello"
+        b = sorgente_biglietti(progetto, da, workspace=workspace, tipo="modello", vicino=radice)(versione)
+        base = f"{a.url.rstrip('/')}/_modello/{progetto}/{versione}"
+        inizio = time.monotonic()
+        voci = []
+        for p in file:
+            rel = p.relative_to(dest).as_posix()
+            corpo = p.read_bytes()
+            chiama("PUT", f"{base}/{rel}", b, corpo)
+            voci.append({"file": rel, "byte": len(corpo)})
+        esito = chiama("POST", f"{base}/pubblica", b, json.dumps({"file": voci}).encode(),
+                       intestazioni={"Content-Type": "application/json"})
+        print(f"  pubblicato {esito['versione']}: {esito['file']} file, {time.monotonic() - inizio:.1f}s")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))