cof-cli 1.0.0__py3-none-any.whl

cof_cli/__init__.py

@@ -0,0 +1,5 @@
+"""cof-cli — reference tooling for COF (Character Open File)."""
+
+__version__ = "1.0.0"
+MIMETYPE = "application/vnd.cof.character+zip"
+SPEC_VERSION = "1.0"

cof_cli/cli.py

@@ -0,0 +1,305 @@
+"""`cof` command line."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import tempfile
+from pathlib import Path
+
+from . import __version__
+from .completeness import compute as compute_completeness
+from .container import make_thumbnail, refresh_asset_index, ContainerError, pack, read_manifest, unpack
+from .convert import card_to_cof_dir, export_soul, read_card_from_png, write_card_to_png
+from .migrate import migrate_any
+from .ops import extract_preset, merge_dirs, extract_tag
+from .model import asset_index, default_preset_id, first, preset_age, resolved
+from .validate import Report, validate_cof, validate_dir
+
+
+def _print_report(rep: Report, as_json: bool) -> int:
+    if as_json:
+        print(json.dumps(rep.to_dict(), ensure_ascii=False, indent=2))
+    else:
+        for e in rep.errors:
+            print(f"ERROR  {e}")
+        for w in rep.warnings:
+            print(f"WARN   {w}")
+        c = rep.info.get("completeness")
+        if c:
+            print(f"completeness: {c['score']}/100 (level {c['level']}) — " + ", ".join(f"{k} {v}" for k, v in c["layers"].items()))
+            print("ready for:    " + (", ".join(c["targets_ready"]) or "—"))
+        cov = rep.info.get("coverage")
+        if cov:
+            print(f"coverage:     {', '.join(cov['elements']) or '—'} ({cov['variants']} variant(s), {cov['presets']} preset(s))")
+        if rep.info.get("presets") and len(rep.info["presets"]) > 1:
+            print("presets:      " + ", ".join(f"{k} {v}" for k, v in rep.info["presets"].items()))
+        t = rep.info.get("tokens")
+        if t and "permanent" in t:
+            print(f"tokens:       permanent {t['permanent']}" + (f", lore {t['lore']}" if "lore" in t else "") + f" ({t['tokenizer']})")
+        print("OK" if rep.ok else f"NOT CONFORMANT ({len(rep.errors)} error(s))")
+    return 0 if rep.ok else 1
+
+
+def cmd_validate(a):
+    p = Path(a.path)
+    if p.is_dir():
+        rep = Report()
+        validate_dir(p, rep, recompute=False)
+    else:
+        rep = validate_cof(p)
+    return _print_report(rep, a.json)
+
+
+def cmd_pack(a):
+    src = Path(a.dir)
+    # hashes first: missing sha256/bytes are schema errors that would otherwise skip the recompute of
+    # completeness / coverage / languages and leave stale figures in the packed manifest
+    mpath = src / "manifest.json"
+    try:
+        m0 = json.loads(mpath.read_text("utf-8"))
+        refresh_asset_index(src, m0, strict=False)
+        mpath.write_text(json.dumps(m0, ensure_ascii=False, indent=2) + "\n", "utf-8")
+    except Exception:
+        pass
+    rep = Report()
+    manifest = validate_dir(src, rep, recompute=True)
+    if rep.errors and not a.force:
+        _print_report(rep, a.json)
+        print("Folder not conformant: fix it or use --force.", file=sys.stderr)
+        return 1
+    if manifest:
+        make_thumbnail(src, manifest)
+        from datetime import datetime, timezone
+        manifest.setdefault("provenance", {})["modified"] = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        (src / "manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", "utf-8")
+    out = Path(a.out) if a.out else src.with_suffix(".cof")
+    try:
+        pack(src, out)
+    except ContainerError as e:
+        print(f"ERROR  {e}", file=sys.stderr)
+        return 1
+    print(f"written: {out} ({out.stat().st_size/1e6:.2f} MB)")
+    return 0
+
+
+def cmd_unpack(a):
+    out = Path(a.out) if a.out else Path(a.cof).with_suffix("")
+    unpack(a.cof, out)
+    print(f"extracted to: {out}")
+    return 0
+
+
+def cmd_info(a):
+    m = read_manifest(a.cof)
+    c = m.get("completeness") or compute_completeness(m)
+    print(json.dumps({"name": m.get("name"), "id": m.get("id"), "cof": m.get("cof"), "age": {p: preset_age(m, p) for p in (m.get("presets") or {})},
+                      "fictional": m.get("fictional"), "size_class": m.get("size_class"), "thumbnail": m.get("thumbnail"),
+                      "completeness": c["file"] if isinstance(c, dict) and "file" in c else c, "coverage": m.get("coverage"),
+                      "presets": {k: {kk: vv for kk, vv in {"label": v.get("label"), "identity": v.get("identity"), "extends": v.get("extends"), "slots": v.get("slots"),
+                                          "alternatives": v.get("alternatives"), "primary_image": v.get("primary_image"),
+                                          "tags": [t.get("id") for t in m.get("preset_tags") or [] if k in (t.get("presets") or [])],
+                                          "score": (v.get("completeness") or {}).get("score")}.items() if vv} for k, v in (m.get("presets") or {}).items()},
+                      "default_preset": m.get("default_preset"),
+                      "variants": {cat: {vid: " · ".join(str(x) for x in (v.get("kind"), v.get("label"), v.get("language"), v.get("identity")) if x)
+                                         for vid, v in (e.get("variants") or {}).items()} for cat, e in (m.get("elements") or {}).items()},
+                      "preset_tags": [{"id": t.get("id"), "facet": t.get("facet"), "presets": t.get("presets")} for t in m.get("preset_tags") or []],
+                      "characters": list((m.get("identities") or {}).keys()) or None,
+                      "tags": m.get("tags"), "assets": len(m.get("assets", []))},
+                     ensure_ascii=False, indent=2))
+    return 0
+
+
+def cmd_tokens(a):
+    p = Path(a.path)
+    rep = Report()
+    if p.is_dir():
+        validate_dir(p, rep, recompute=False)
+    else:
+        with tempfile.TemporaryDirectory() as td:
+            validate_dir(unpack(p, td), rep, recompute=False)
+    print(json.dumps(rep.info.get("tokens", {}), ensure_ascii=False, indent=2))
+    return 0
+
+
+def cmd_embed_text(a):
+    from .convert import write_text_to_png
+    png = Path(a.png).read_bytes(); text = Path(a.text).read_text("utf-8")
+    out = Path(a.out) if a.out else Path(a.png).with_name(Path(a.png).stem + ".cof.png")
+    out.write_bytes(write_text_to_png(png, text)); print(f"{out} — {len(text)} characters in iTXt Description")
+
+
+def cmd_read_text(a):
+    from .convert import read_text_from_image
+    r = read_text_from_image(Path(a.image).read_bytes())
+    if not r:
+        print("no embedded descriptive text"); return 1
+    print(f"[{r['source']}] {len(r['text'])} characters\n"); print(r["text"])
+
+
+def cmd_import(a):
+    src = Path(a.src)
+    if src.suffix.lower() == ".png":
+        png = src.read_bytes()
+        card = read_card_from_png(png)
+    elif src.suffix.lower() == ".json":
+        card = json.loads(src.read_text("utf-8"))
+        png = None
+        if "spec" not in card:
+            card = {"spec": "chara_card_v2", "spec_version": "2.0", "data": card}
+    else:
+        print("expected source: .png (card) or .json (card)", file=sys.stderr)
+        return 1
+    dest = Path(a.out) if a.out else Path(src.stem)
+    card_to_cof_dir(card, dest, png=png if a.keep_png else None, age=a.age, fictional=not a.real, language=a.lang)
+    rep = Report()
+    validate_dir(dest, rep, recompute=True)
+    print(f"COF folder created: {dest}")
+    return _print_report(rep, a.json)
+
+
+def cmd_export(a):
+    src = Path(a.src)
+    with tempfile.TemporaryDirectory() as td:
+        d = src if src.is_dir() else unpack(src, td)
+        manifest = json.loads((d / "manifest.json").read_text("utf-8"))
+        fmt = a.format
+        out = Path(a.out) if a.out else None
+        pid = a.preset or default_preset_id(manifest)
+        r = resolved(manifest, pid)
+        A = asset_index(manifest)
+        card_path = (first(r, "personality") or {}).get("card")
+        if fmt in ("png", "card") and not card_path:
+            print("this preset has no personality variant (card.json)", file=sys.stderr)
+            return 1
+        if fmt == "png":
+            card = json.loads((d / card_path).read_text("utf-8"))
+            head = next((A[i]["path"] for i in (first(r, "appearance", "face") or {}).get("images", []) if i in A and A[i].get("subject") == "head" and A[i].get("angle") == "front"), None)
+            if head and head.lower().endswith(".png"):
+                png = (d / head).read_bytes()
+            else:
+                png = _placeholder_png(d / head if head else None)
+            out = out or Path(f"{manifest['name']}.png")
+            out.write_bytes(write_card_to_png(png, card))
+        elif fmt == "soul":
+            soul, identity = export_soul(d, pid)
+            out = out or Path(".")
+            out.mkdir(parents=True, exist_ok=True)
+            (out / "SOUL.md").write_text(soul, "utf-8")
+            (out / "IDENTITY.md").write_text(identity, "utf-8")
+        elif fmt == "agent":
+            from .convert import export_agent
+            out = out or Path(f"{manifest['name']}-agent")
+            done = export_agent(d, out, pid)
+            print(f"skills: {', '.join(done['skills']) or '—'} · memories: {len(done['memories'])} · documents: {len(done['documents'])}")
+        elif fmt == "card":
+            card = json.loads((d / card_path).read_text("utf-8"))
+            out = out or Path(f"{manifest['name']}.card.json")
+            out.write_text(json.dumps(card, ensure_ascii=False, indent=2), "utf-8")
+        else:
+            print(f"unsupported format: {fmt}", file=sys.stderr)
+            return 1
+    print(f"exported: {out}")
+    return 0
+
+
+def cmd_merge(a):
+    dirs = []
+    for src in a.sources:
+        p = Path(src)
+        if p.is_file():
+            td = Path(tempfile.mkdtemp()); unpack(p, td); dirs.append(td)
+        else:
+            dirs.append(p)
+    merge_dirs(dirs, Path(a.out))
+    rep = Report(); validate_dir(Path(a.out), rep, recompute=True)
+    Path(a.out, "manifest.json").write_text(json.dumps(json.loads(Path(a.out, "manifest.json").read_text("utf-8")) | {}, ensure_ascii=False, indent=2) + "\n", "utf-8")
+    print(f"merged into: {a.out}")
+    return _print_report(rep, a.json)
+
+
+def cmd_extract(a):
+    src = Path(a.src)
+    with tempfile.TemporaryDirectory() as td:
+        d = src if src.is_dir() else unpack(src, td)
+        if a.tag:
+            extract_tag(d, Path(a.out), a.tag)
+        elif getattr(a, "identity", None):
+            from .ops import extract_identity
+            extract_identity(d, Path(a.out), a.identity)
+        else:
+            extract_preset(d, Path(a.out), a.preset)
+        if getattr(a, "no_intimate", False):
+            from .ops import strip_intimate
+            gone = strip_intimate(Path(a.out))
+            print(f"--no-intimate: removed {', '.join(gone) or 'nothing'}; allowSexualUsage set to false — review tags.content")
+    rep = Report(); validate_dir(Path(a.out), rep, recompute=True)
+    what = 'tags ' + '+'.join(a.tag) if a.tag else ('character ' + a.identity if getattr(a, "identity", None) else 'preset ' + a.preset)
+    print(f"{what} extracted to: {a.out}")
+    return _print_report(rep, a.json)
+
+
+def cmd_migrate(a):
+    m = migrate_any(Path(a.dir))
+    rep = Report()
+    validate_dir(Path(a.dir), rep, recompute=True)
+    Path(a.dir, "manifest.json").write_text(json.dumps(m | {k: v for k, v in json.loads(Path(a.dir, "manifest.json").read_text("utf-8")).items()}, ensure_ascii=False, indent=2) + "\n", "utf-8")
+    print(f"migrated to v{m.get('cof')}: {a.dir}")
+    return _print_report(rep, a.json)
+
+
+def _placeholder_png(image_path: Path | None) -> bytes:
+    """1024² PNG: converted from the given image if Pillow is available, else a flat grey PNG."""
+    try:
+        from PIL import Image
+        import io
+        if image_path and image_path.is_file():
+            im = Image.open(image_path).convert("RGB")
+        else:
+            im = Image.new("RGB", (1024, 1024), (64, 64, 72))
+        im = im.resize((1024, 1024))
+        buf = io.BytesIO()
+        im.save(buf, "PNG")
+        return buf.getvalue()
+    except Exception:
+        import zlib, struct
+        from .convert import png_build
+        w = h = 64
+        raw = b"".join(b"\x00" + bytes([64, 64, 72]) * w for _ in range(h))
+        ihdr = struct.pack(">IIBBBBB", w, h, 8, 2, 0, 0, 0)
+        return png_build([(b"IHDR", ihdr), (b"IDAT", zlib.compress(raw)), (b"IEND", b"")])
+
+
+def main(argv=None) -> int:
+    for stream in (sys.stdout, sys.stderr):      # Windows consoles default to cp1252: never crash on « — ✔ é »
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")
+        except Exception:
+            pass
+    ap = argparse.ArgumentParser(prog="cof", description="COF — Character Open File tooling")
+    ap.add_argument("--version", action="version", version=f"cof-cli {__version__}")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    s = sub.add_parser("validate", help="validate a .cof or a character folder"); s.add_argument("path"); s.add_argument("--json", action="store_true"); s.set_defaults(fn=cmd_validate)
+    s = sub.add_parser("pack", help="folder → .cof (recomputes hashes and completeness)"); s.add_argument("dir"); s.add_argument("-o", "--out"); s.add_argument("--force", action="store_true"); s.add_argument("--json", action="store_true"); s.set_defaults(fn=cmd_pack)
+    s = sub.add_parser("unpack", help=".cof → folder"); s.add_argument("cof"); s.add_argument("-o", "--out"); s.set_defaults(fn=cmd_unpack)
+    s = sub.add_parser("info", help="summary of a .cof"); s.add_argument("cof"); s.set_defaults(fn=cmd_info)
+    s = sub.add_parser("tokens", help="token estimate per block"); s.add_argument("path"); s.set_defaults(fn=cmd_tokens)
+    s = sub.add_parser("embed-text", help="write a text (.md/.txt) into a PNG as iTXt 'Description' — readable by the builder (personality + appearance)"); s.add_argument("png"); s.add_argument("text"); s.add_argument("-o", "--out"); s.set_defaults(fn=cmd_embed_text)
+    s = sub.add_parser("read-text", help="show the descriptive text embedded in an image (PNG/JPEG: iTXt, XMP, EXIF)"); s.add_argument("image"); s.set_defaults(fn=cmd_read_text)
+    s = sub.add_parser("import", help="PNG/JSON card (CCv2/V3) → COF folder"); s.add_argument("src"); s.add_argument("-o", "--out"); s.add_argument("--age", type=int); s.add_argument("--real", action="store_true", help="character based on a real person (consent required)"); s.add_argument("--lang", default="en"); s.add_argument("--keep-png", action="store_true", help="keep the PNG as the head.front view"); s.add_argument("--json", action="store_true"); s.set_defaults(fn=cmd_import)
+    s = sub.add_parser("export", help="folder/.cof → png | soul | card | agent (workspace: SOUL.md, IDENTITY.md, skills/, memories) — from the default preset or --preset"); s.add_argument("src"); s.add_argument("--format", choices=["png", "soul", "card", "agent"], required=True); s.add_argument("-o", "--out"); s.add_argument("--preset"); s.set_defaults(fn=cmd_export)
+    s = sub.add_parser("migrate", help="folder v0.2 … v0.5 → v1.0"); s.add_argument("dir"); s.add_argument("--json", action="store_true"); s.set_defaults(fn=cmd_migrate)
+    s = sub.add_parser("merge", help="merge several .cof files/folders (same name, nickname, fictional status and morphology class ⇒ same identity, otherwise multiple identities)"); s.add_argument("sources", nargs="+"); s.add_argument("-o", "--out", required=True); s.add_argument("--json", action="store_true"); s.set_defaults(fn=cmd_merge)
+    s = sub.add_parser("extract", help="extract a preset, a character (--identity), or the presets carrying one or more tags (intersection), into a lighter COF folder"); s.add_argument("src"); g = s.add_mutually_exclusive_group(required=True); g.add_argument("--preset"); g.add_argument("--identity", help="one character: all its presets, elements, files and rights"); g.add_argument("--tag", action="append", help="repeatable: --tag english --tag age-12"); s.add_argument("-o", "--out", required=True); s.add_argument("--json", action="store_true"); s.add_argument("--no-intimate", action="store_true", help="safe-for-work slice: drop intimate variants, allowSexualUsage = false"); s.set_defaults(fn=cmd_extract)
+
+    a = ap.parse_args(argv)
+    try:
+        return a.fn(a)
+    except (ContainerError, ValueError) as e:
+        print(f"ERROR  {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

cof_cli/completeness.py

@@ -0,0 +1,131 @@
+"""Completeness KPI (v0.5) — per preset, from categories/kinds. Derived assets never count."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .model import asset_index, by_kind, default_preset_id, first, preset_identity, preset_ids, resolved
+
+WEIGHTS = {"identity": 0.10, "personality": 0.20, "appearance": 0.20, "physique": 0.05,
+           "voice": 0.15, "volume": 0.10, "motion": 0.05, "rights": 0.15}
+
+
+def _load(src: Path | None, rel):
+    try:
+        return json.loads((src / rel).read_text("utf-8")) if src and rel and (src / rel).is_file() else None
+    except Exception:
+        return None
+
+
+def compute_preset(manifest: dict, pid: str | None, src: Path | None = None) -> dict:
+    m = manifest
+    r = resolved(m, pid)
+    A = asset_index(m)
+    ident = preset_identity(m, pid)
+    L: dict[str, int] = {}
+    imgs = lambda v: [A[i] for i in (v or {}).get("images", []) if i in A]
+
+    from .model import preset_age
+    s = 20 * bool(ident.get("name")) + 20 * (preset_age(m, pid) is not None) + 20 * bool(ident.get("summary"))
+    s += 10 * bool(m.get("languages")) + 10 * bool(ident.get("morphology"))
+    tags = m.get("tags", {}) or {}
+    s += 10 * bool(tags.get("content")) + 10 * isinstance(tags.get("ip"), dict)
+    L["identity"] = min(100, s)
+
+    p = first(r, "personality")
+    s = 0
+    if p and p.get("kind") == "card" and p.get("card"):
+        s += 30
+        card = _load(src, p["card"]); d = (card or {}).get("data", {})
+        if card is None and src is None:
+            s += 25
+        s += 10 * bool(d.get("description")) + 10 * bool(d.get("personality")) + 5 * bool(d.get("scenario")) + 10 * bool(d.get("first_mes")) + 10 * bool(d.get("mes_example"))
+        s += 10 * bool(p.get("story") or p.get("lorebook") or d.get("character_book"))
+    elif p and p.get("kind") == "description":
+        n = len(p.get("text") or "")
+        s += 35 + 15 * (n >= 400) + 10 * (n >= 1500)        # a rich free-text sheet is usable for chat (≥ 50)
+    s += 15 * bool(p and p.get("psyche"))
+    L["personality"] = min(100, s)
+
+    f = first(r, "appearance", "face"); fi = imgs(f)
+    s = 25 * any(a.get("subject") == "head" and a.get("angle") == "front" for a in fi) + 10 * (len(fi) >= 2)
+    s += 10 * bool(f and (f.get("params") or f.get("mesh")))
+    s += 5 * bool(first(r, "volume3d", "face-mesh"))
+    s += 5 * bool(first(r, "appearance", "hair"))
+    b = first(r, "appearance", "body"); bi = imgs(b)
+    s += 10 * bool(bi) + 5 * (len(bi) >= 2) + 5 * bool(b and b.get("params"))
+    from .model import preset_primary_image
+    pim = A.get(preset_primary_image(m, pid) or "") or {}
+    outfit_seen = pim.get("subject") == "body" or pim.get("framing") == "full"
+    s += 10 * bool(by_kind(r, "appearance", "clothing") or outfit_seen)   # outfit applied, or visible on the primary image
+    cs = first(r, "appearance", "character-sheet") or first(r, "appearance", "reference-set")
+    if not fi and cs and imgs(cs):
+        s += 20                       # a sheet / reference set gives a usable look even without split views
+    s += 15 * bool(r.get("identity_weights"))
+    L["appearance"] = min(100, s)
+
+    po = r.get("posture", [])
+    s = 60 * bool(po) + 40 * any(v.get("kind") in ("openpose", "attitude", "photo", "photos") for v in po)
+    L["physique"] = min(100, s)
+
+    v = first(r, "voice"); samples = [A[i] for i in (v or {}).get("samples", []) if i in A]
+    s = 0
+    if samples:
+        s += 30 + 10 * all(a.get("transcript") for a in samples)   # transcript optional: bonus
+        d = sorted(a.get("duration_s", 0) for a in samples)
+        s += 10 * (d[0] <= 12 and d[-1] >= 25)
+    s += 25 * bool(v and (v.get("profile") or v.get("kind") == "described")) + 20 * bool(v and v.get("vec")) + 5 * bool(v and v.get("engines"))
+    L["voice"] = min(100, s)
+
+    mesh = first(r, "volume3d", "mesh")
+    s = 60 * bool(mesh and mesh.get("path")) + 10 * bool(mesh and mesh.get("rig")) + 15 * bool(first(r, "volume3d", "point-cloud")) + 15 * bool(first(r, "volume3d", "print"))
+    L["volume"] = min(100, s)
+
+    mo = r.get("motion", [])
+    clips = [A[i] for v in mo for i in (v.get("clips") or []) if i in A]
+    vids = [A[i] for v in mo for i in (v.get("videos") or []) if i in A]
+    s = 60 * bool(clips or vids) + 25 * any(v.get("visemes") for v in mo) + 15 * (bool(clips) and all(a.get("rig") for a in clips))
+    s += 30 * any(v.get("kind") == "attitude" for v in mo)   # movement signature (attitude.json) allowed here
+    L["motion"] = min(100, s)
+
+    rg = m.get("rights", {}) or {}
+    assets = m.get("assets", [])
+    s = 40 * bool(rg.get("permissions")) + 15 * (not assets or all(a.get("license") for a in assets))
+    needs_consent = (ident.get("fictional") is False) or any(a.get("role") == "voice-consent" for a in assets)
+    s += 20 * (bool(rg.get("consent") or ident.get("consent")) if needs_consent else True)
+    prov = m.get("provenance", {}) or {}
+    s += 10 * bool(prov.get("source")) + 15 * bool(prov.get("c2pa") or prov.get("signatures"))
+    L["rights"] = min(100, s)
+
+    score = round(sum(L[k] * w for k, w in WEIGHTS.items()))
+    level = "A" if score >= 85 else "B" if score >= 60 else "C" if score >= 35 else "D"
+    t = []
+    if L["personality"] >= 50:
+        t += ["chat-text", "agent-persona"]
+    if any(v.get("kind") in ("skill", "memory") for v in r.get("files", [])):
+        t.append("agent-runtime")       # embedded skills / memories: ready for an agent (SOUL.md + skills/ + MEMORY.md)
+    if L["personality"] >= 50 and L["voice"] >= 40:
+        t.append("chat-voice")
+    if L["appearance"] >= 25:
+        t.append("image-video-gen")
+    if L["voice"] >= 40 and L["appearance"] >= 40 and (f and (f.get("mesh") or f.get("params")) or mesh):
+        t.append("video-realtime")
+    if mesh and mesh.get("path"):
+        t.append("game-3d")
+    if first(r, "volume3d", "print"):
+        t.append("print-3d")
+    if L["rights"] >= 60:
+        t.append("archive")
+    return {"score": score, "level": level, "layers": L, "targets_ready": t}
+
+
+def compute(manifest: dict, src: Path | None = None) -> dict:
+    pids = preset_ids(manifest)
+    per = {pid: compute_preset(manifest, pid, src) for pid in pids}
+    dp = default_preset_id(manifest)
+    file_level = per[dp] if dp in per else compute_preset(manifest, None, src)
+    elements = manifest.get("elements", {}) or {}
+    coverage = {"elements": [e for e, v in elements.items() if (v or {}).get("variants")],
+                "variants": sum(len((v or {}).get("variants", {})) for v in elements.values()),
+                "presets": len(pids), "identities": len(manifest.get("identities") or {}) or 1}
+    return {"file": file_level, "presets": per, "coverage": coverage}