cg-code-graph 0.21.2__tar.gz → 0.22.0__tar.gz

{cg_code_graph-0.21.2/cg_code_graph.egg-info → cg_code_graph-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.21.2
+Version: 0.22.0
 Summary: cg: a code graph of routes, calls, data access and platform boundaries for agents and humans (CLI + MCP server)
 Author: cyberchronos00
 License-Expression: MIT
@@ -93,7 +93,7 @@ Go and others: import a SCIP index with `cg index --scip FILE`. Run `cg doctor`
 - Across repos: `cg link` matches client HTTP calls (frontends and Laravel / Guzzle backends) to server routes, and checks request keys (Laravel FormRequest, Elysia schemas, Nuxt / TypeScript bodies).
 - Route guards: `cg routes --writes --unguarded` lists routes that write with no auth guard. Laravel checks inside the action count as inline guards unless `--strict`.
 - Security views: `cg surface` lists the inbound / outbound attack surface and findings (hardcoded credentials, plaintext protocols, unverified webhooks, unguarded handlers, listeners on all interfaces, disabled TLS / SSH verification, plaintext gRPC, exposed IPC, outbound URLs built from request input) as text, JSON or SARIF, with `--fail-on` for CI.
-- MCP server (`cg-mcp`) so agents query the graph instead of grepping.
+- MCP server (`cg-mcp`) so agents query the graph instead of grepping. One server can serve many graphs (`graphs` plus an optional `graph` argument); a single `--db` stays one graph. See [MCP](https://code-graph.cyberchronos00.workers.dev/docs/mcp).
 - Visual view (`cg serve`) and plan checks (`cg plan check`) for planned changes.
 
 ## Docs

{cg_code_graph-0.21.2 → cg_code_graph-0.22.0}/README.md

@@ -66,7 +66,7 @@ Go and others: import a SCIP index with `cg index --scip FILE`. Run `cg doctor`
 - Across repos: `cg link` matches client HTTP calls (frontends and Laravel / Guzzle backends) to server routes, and checks request keys (Laravel FormRequest, Elysia schemas, Nuxt / TypeScript bodies).
 - Route guards: `cg routes --writes --unguarded` lists routes that write with no auth guard. Laravel checks inside the action count as inline guards unless `--strict`.
 - Security views: `cg surface` lists the inbound / outbound attack surface and findings (hardcoded credentials, plaintext protocols, unverified webhooks, unguarded handlers, listeners on all interfaces, disabled TLS / SSH verification, plaintext gRPC, exposed IPC, outbound URLs built from request input) as text, JSON or SARIF, with `--fail-on` for CI.
-- MCP server (`cg-mcp`) so agents query the graph instead of grepping.
+- MCP server (`cg-mcp`) so agents query the graph instead of grepping. One server can serve many graphs (`graphs` plus an optional `graph` argument); a single `--db` stays one graph. See [MCP](https://code-graph.cyberchronos00.workers.dev/docs/mcp).
 - Visual view (`cg serve`) and plan checks (`cg plan check`) for planned changes.
 
 ## Docs

{cg_code_graph-0.21.2 → cg_code_graph-0.22.0}/cg_code_graph/__init__.py

@@ -1,2 +1,2 @@
 """code-graph: deterministic code knowledge graph (beta)."""
-__version__ = "0.21.2"
+__version__ = "0.22.0"

{cg_code_graph-0.21.2 → cg_code_graph-0.22.0}/cg_code_graph/cli.py

@@ -73,6 +73,13 @@ def _add_install_parser(sub, uninstall: bool):
     p.add_argument("--uninstall", action="store_true", help="remove the entry instead of writing it")
     p.add_argument("--dry-run", action="store_true", help="print the exact changes and write nothing")
     p.add_argument("--yes", action="store_true", help="skip the confirmation prompt")
+    if not uninstall:
+        p.add_argument("--registry", action="store_true",
+                       help="global single entry: cg-mcp with no --db; graphs come from the registry")
+        p.add_argument("--migrate", action="store_true",
+                       help="fold per-repo cg-* host entries into the graph registry (dry run unless --apply)")
+        p.add_argument("--apply", action="store_true", help="with --migrate, write the registry and the host config")
+        p.add_argument("--graphs", help="registry file for --migrate (default: ~/.config/cg/graphs.toml)")
 
 
 def _impact_labels(rows: list[dict], name_of, group_of) -> list[str]:
@@ -506,9 +513,14 @@ def main(argv=None):
                       mcp_file=a.mcp_file, dry_run=a.dry_run, assume_yes=a.yes)
     if a.cmd in ("install", "uninstall"):
         from .mcp_install import run as run_install
+        registry = bool(getattr(a, "registry", False))
+        migrate = bool(getattr(a, "migrate", False))
+        if (registry or migrate) and not a.project:
+            a.glob = True
         return run_install(a.host, scope="global" if a.glob else "project", root=a.dir, db=a.db,
                            tools=a.tools, portable=a.portable, remove=a.cmd == "uninstall" or a.uninstall,
-                           dry_run=a.dry_run, assume_yes=a.yes)
+                           dry_run=a.dry_run, assume_yes=a.yes, registry=registry, migrate=migrate,
+                           apply=bool(getattr(a, "apply", False)), graphs=getattr(a, "graphs", None))
     if a.cmd == "hooks":
         from . import hooks as HK
         return HK.run(a.action, root=a.dir, db=a.db, dry_run=a.dry_run, assume_yes=a.yes)
@@ -675,16 +687,19 @@ def main(argv=None):
         if res.get("platform"):
             from .platforms import render_filter
             print(render_filter(res["platform"]))
-            if res["platform"].get("targets_not_built"):
-                print(f"not built for {a.platform}: {', '.join(res['platform']['targets_not_built'][:6])}")
+            dropped = res["platform"].get("targets_not_built") or []
+            if dropped and res["targets"]:
+                print(f"not built for {a.platform}: {', '.join(dropped[:6])}")
+            if dropped and not res["targets"]:
+                msg = f"{a.spec} is not built for {a.platform}: nothing calls it there"
+                if Q.divergence_lists(st, a.platform, dropped):
+                    msg += (f" (`cg platforms divergence --target {a.platform}` lists references to it that would not build)")
+                print(msg); return
         print(f"targets: {res['targets'][:5]}")
         if not res["targets"]:
             print(f"no method matches {a.spec!r}; try `search` with part of the name"); return
-        if a.platform and res["targets"] and set(res["platform"]["targets_not_built"]) == set(res["targets"]):
-            msg = f"{a.spec} is not built for {a.platform}: nothing calls it there"
-            if Q.divergence_lists(st, a.platform, res["targets"]):
-                msg += (f" (`cg platforms divergence --target {a.platform}` lists references to it that would not build)")
-            print(msg); return
+        for d in res.get("default_arguments") or []:
+            print(f"via default argument: {d['src']} @ {d['file']}:{d['line']}")
         for line in Q.override_lines(res):
             print(line)
         if res.get("connections"):

{cg_code_graph-0.21.2 → cg_code_graph-0.22.0}/cg_code_graph/indexer.py

@@ -28,6 +28,19 @@ from .plugins.flutter.plugin import FlutterPlugin
 from .plugins.nest.plugin import NestPlugin
 from .plugins.nextjs.plugin import NextPlugin
 from .plugins.express.plugin import ExpressPlugin
+import subprocess
+
+
+def _git_head(root) -> str | None:
+    """Commit indexed for this root, when it is a git work tree."""
+    try:
+        proc = subprocess.run(["git", "-C", str(root), "rev-parse", "HEAD"],
+                              capture_output=True, text=True, timeout=8)
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if proc.returncode != 0:
+        return None
+    return (proc.stdout or "").strip() or None
 from .plugins.astro.plugin import AstroPlugin
 from .plugins.kotlin.plugin import KotlinPlugin
 from .plugins.java.plugin import JavaPlugin
@@ -464,6 +477,9 @@ def index_project(root: str | Path, db_path: str | Path, name: str | None = None
     stats["nodes"] = len(builder.nodes)
     stats["edges"] = len(builder.edges)
     stats["index_seconds"] = round(time.time() - t0, 2)
-    store.set_meta(project=project.name, root=str(project.root), stats=stats, indexed_at=time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime()))
+    head = _git_head(project.root)
+    extra = {"commit": head} if head else {}
+    store.set_meta(project=project.name, root=str(project.root), stats=stats,
+                   indexed_at=time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime()), **extra)
     store.db.close()
     return stats

{cg_code_graph-0.21.2 → cg_code_graph-0.22.0}/cg_code_graph/link.py

@@ -497,10 +497,23 @@ def link_many(repos: list[tuple[str, str, str]], out_db: str, *, allow: dict | N
     for name, path, _role in repos:
         got = for_graph(GraphStore(path))
         cov.update({name: next(iter(got.values()))} if len(got) == 1 else got)
+    commits = {}
+    for name, path, _role in repos:
+        try:
+            member_st = GraphStore(path)
+            try:
+                member = member_st.meta()
+            finally:
+                member_st.db.close()
+        except Exception:
+            member = {}
+        if member.get("commit"):
+            commits[name] = member["commit"]
     store.set_meta(project="+".join(names), stats=stats, repos=names, coverage=cov,
                    sources={name: str(Path(path).resolve()) for name, path, _role in repos},
                    repo_roles={name: role for name, _path, role in repos}, link_clients=clients, link_allow=allow,
-                   indexed_at=time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime()))
+                   indexed_at=time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime()),
+                   **({"commit": commits} if commits else {}))
     db.close()
     return {"stats": stats, "results": results, "payload_issues": issues, "uncalled_routes": uncalled,
             "webhook_subscriptions": subscriptions, "external_callbacks": callbacks}

cg_code_graph-0.22.0/cg_code_graph/mcp_graphs.py

@@ -0,0 +1,438 @@
+"""Graph registry for one cg-mcp process serving many graphs.
+
+Entries come from a config file (``~/.config/cg/graphs.toml``, or ``CG_GRAPHS``),
+repeatable ``--db`` / ``--db NAME=PATH``, and ``--db-dir``. A combined graph is one
+entry with several repo roots. Each call opens its own connection.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .core.store import GraphStore
+
+
+class GraphError(Exception):
+    """A graph name is unknown, or more than one graph matches and none was chosen."""
+
+
+@dataclass
+class GraphEntry:
+    name: str
+    db: Path
+    roots: list[Path] = field(default_factory=list)
+    default: bool = False
+    tools: str | None = None
+
+    def label(self) -> str:
+        roots = ", ".join(str(r) for r in self.roots) or "(no roots)"
+        return f"{self.name} [{roots}]"
+
+
+@dataclass
+class Registry:
+    entries: list[GraphEntry]
+    default: str | None = None
+    source: str = ""
+
+    def by_name(self) -> dict[str, GraphEntry]:
+        return {e.name: e for e in self.entries}
+
+    def names(self) -> list[str]:
+        return [e.name for e in self.entries]
+
+
+def default_graphs_path() -> Path:
+    """``$XDG_CONFIG_HOME/cg/graphs.toml``, else ``~/.config/cg/graphs.toml``."""
+    base = os.environ.get("XDG_CONFIG_HOME")
+    root = Path(base) if base else Path.home() / ".config"
+    return root / "cg" / "graphs.toml"
+
+
+def git_head(root: Path) -> str | None:
+    """HEAD of ``root``, or None when git is missing or ``root`` is not a work tree."""
+    try:
+        proc = subprocess.run(
+            ["git", "-C", str(root), "rev-parse", "HEAD"],
+            capture_output=True, text=True, timeout=8,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if proc.returncode != 0:
+        return None
+    sha = (proc.stdout or "").strip()
+    return sha or None
+
+
+def _valid_name(name: str) -> bool:
+    return bool(name) and all(c.isalnum() or c in "_.-" for c in name)
+
+
+def parse_db_arg(text: str) -> tuple[str, Path]:
+    """``NAME=PATH`` or a bare path (the name is the file stem)."""
+    raw = text.strip()
+    if "=" in raw:
+        name, path = raw.split("=", 1)
+        name, path = name.strip(), path.strip()
+        if _valid_name(name) and "/" not in name and "\\" not in name and path:
+            return name, Path(path).expanduser()
+    path = Path(raw).expanduser()
+    return path.stem or "graph", path
+
+
+def roots_from_db(db: Path) -> list[Path]:
+    """Repo roots recorded in this graph, including member roots of a combined graph."""
+    found: list[Path] = []
+    seen: set[str] = set()
+
+    def add(p) -> None:
+        if not p:
+            return
+        try:
+            path = Path(p).expanduser()
+        except (TypeError, ValueError):
+            return
+        key = str(path)
+        if key in seen:
+            return
+        seen.add(key)
+        found.append(path)
+
+    try:
+        st = GraphStore(db)
+        try:
+            meta = st.meta()
+        finally:
+            st.db.close()
+    except Exception:
+        return []
+    add(meta.get("root"))
+    sources = meta.get("sources") or {}
+    if isinstance(sources, dict):
+        for member in sources.values():
+            mp = Path(str(member)).expanduser()
+            if mp.suffix == ".db":
+                try:
+                    inner = GraphStore(mp)
+                    try:
+                        add(inner.meta().get("root"))
+                    finally:
+                        inner.db.close()
+                except Exception:
+                    pass
+            elif mp.is_dir():
+                add(mp)
+    return found
+
+
+def _entry_from_mapping(name: str, body: dict, default_name: str | None) -> GraphEntry:
+    if "db" not in body:
+        raise GraphError(f"graph {name}: missing db")
+    db = Path(str(body["db"])).expanduser()
+    raw_roots = body.get("roots") or body.get("root") or []
+    if isinstance(raw_roots, str):
+        raw_roots = [raw_roots]
+    roots = [Path(str(r)).expanduser() for r in raw_roots]
+    if not roots:
+        roots = roots_from_db(db)
+    is_default = bool(body.get("default")) or name == default_name
+    tools = body.get("tools")
+    return GraphEntry(name=name, db=db, roots=roots, default=is_default,
+                      tools=str(tools) if isinstance(tools, str) and tools else None)
+
+
+def load_toml(path: Path) -> tuple[list[GraphEntry], str | None]:
+    """Read a registry file. Supports ``[[graphs]]`` and ``[graphs.NAME]``."""
+    try:
+        data = tomllib.loads(path.read_text(encoding="utf-8"))
+    except (OSError, tomllib.TOMLDecodeError) as ex:
+        raise GraphError(f"cannot read graph registry {path}: {ex}") from ex
+    if not isinstance(data, dict):
+        raise GraphError(f"cannot read graph registry {path}: expected a table")
+    default = data.get("default")
+    default_name = str(default) if isinstance(default, str) and default else None
+    entries: list[GraphEntry] = []
+    graphs = data.get("graphs")
+    if isinstance(graphs, list):
+        for i, body in enumerate(graphs):
+            if not isinstance(body, dict) or not body.get("name"):
+                raise GraphError(f"{path}: [[graphs]] item {i} needs a name")
+            entries.append(_entry_from_mapping(str(body["name"]), body, default_name))
+    elif isinstance(graphs, dict):
+        for name, body in graphs.items():
+            if isinstance(body, dict) and "db" in body:
+                entries.append(_entry_from_mapping(str(name), body, default_name))
+            elif isinstance(body, list):
+                for item in body:
+                    if isinstance(item, dict):
+                        entries.append(_entry_from_mapping(str(item.get("name") or name), item, default_name))
+    if default_name and not any(e.name == default_name for e in entries):
+        raise GraphError(f"{path}: default {default_name!r} is not a registered graph")
+    return entries, default_name
+
+
+def entries_from_db_args(args: list[str]) -> list[GraphEntry]:
+    out: list[GraphEntry] = []
+    for text in args:
+        name, db = parse_db_arg(text)
+        out.append(GraphEntry(name=name, db=db, roots=roots_from_db(db)))
+    return out
+
+
+def entries_from_dir(directory: Path) -> list[GraphEntry]:
+    directory = directory.expanduser()
+    if not directory.is_dir():
+        raise GraphError(f"--db-dir is not a directory: {directory}")
+    out = []
+    for db in sorted(directory.glob("*.db")):
+        if db.name.endswith(("-wal", "-shm")):
+            continue
+        out.append(GraphEntry(name=db.stem, db=db, roots=roots_from_db(db)))
+    return out
+
+
+def merge_entries(groups: list[list[GraphEntry]]) -> list[GraphEntry]:
+    """Later groups replace earlier entries with the same name."""
+    order: list[str] = []
+    by: dict[str, GraphEntry] = {}
+    for group in groups:
+        for entry in group:
+            if entry.name not in by:
+                order.append(entry.name)
+            by[entry.name] = entry
+    return [by[n] for n in order]
+
+
+def build_registry(*, dbs: list[str] | None = None, db_dir: str | None = None,
+                   config: Path | None = None, default: str | None = None,
+                   read_config: bool = True) -> Registry:
+    groups: list[list[GraphEntry]] = []
+    source = []
+    file_default = None
+    if read_config and config is not None:
+        if not config.is_file():
+            raise GraphError(f"graph registry not found: {config}")
+        loaded, file_default = load_toml(config)
+        groups.append(loaded)
+        source.append(str(config))
+    if db_dir:
+        groups.append(entries_from_dir(Path(db_dir)))
+        source.append(f"dir:{db_dir}")
+    if dbs:
+        groups.append(entries_from_db_args(dbs))
+        source.append("cli")
+    entries = merge_entries(groups)
+    chosen = default or file_default
+    if chosen is None:
+        marked = [e.name for e in entries if e.default]
+        chosen = marked[-1] if marked else None
+    if chosen and chosen not in {e.name for e in entries}:
+        raise GraphError(f"default graph {chosen!r} is not registered")
+    if not entries:
+        raise GraphError("no graphs registered")
+    return Registry(entries=entries, default=chosen, source=", ".join(source))
+
+
+def save_toml(path: Path, entries: list[GraphEntry], default: str | None = None) -> None:
+    """Write a registry. Caller backs up an existing file."""
+    lines: list[str] = []
+    if default:
+        lines.append(f"default = {_toml_str(default)}")
+        lines.append("")
+    for entry in entries:
+        lines.append("[[graphs]]")
+        lines.append(f"name = {_toml_str(entry.name)}")
+        lines.append(f"db = {_toml_str(str(entry.db))}")
+        roots = ", ".join(_toml_str(str(r)) for r in entry.roots)
+        lines.append(f"roots = [{roots}]")
+        if entry.tools:
+            lines.append(f"tools = {_toml_str(entry.tools)}")
+        lines.append("")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(lines).rstrip() + "\n", encoding="utf-8")
+
+
+def _toml_str(text: str) -> str:
+    return '"' + text.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def _under(root: Path, text: str) -> bool:
+    """True when ``text`` is a path inside ``root`` (absolute, cwd-relative, or root-relative)."""
+    raw = text.replace("\\", "/").split("#", 1)[0].strip()
+    if not raw or raw.startswith(("page:", "repo:", "table:", "column:", "connection:", "env:", "config:")):
+        return False
+    if "/" not in raw and not raw.startswith("."):
+        return False
+    try:
+        base = root.expanduser().resolve()
+    except OSError:
+        return False
+    candidates = []
+    path = Path(raw)
+    if path.is_absolute():
+        candidates.append(path)
+    else:
+        candidates.append(Path.cwd() / path)
+        candidates.append(base / path)
+    for cand in candidates:
+        try:
+            cand.resolve().relative_to(base)
+            return True
+        except (ValueError, OSError):
+            continue
+    return False
+
+
+def _matches(entry: GraphEntry, texts: list[str]) -> bool:
+    return any(_under(root, text) for root in entry.roots for text in texts)
+
+
+def _choice_error(entries: list[GraphEntry]) -> GraphError:
+    listed = ", ".join(e.label() for e in entries)
+    return GraphError("ambiguous graph: pass graph= one of: " + listed)
+
+
+def _root_set(entry: GraphEntry) -> set[Path]:
+    out = set()
+    for root in entry.roots:
+        try:
+            out.add(root.expanduser().resolve())
+        except OSError:
+            out.add(root)
+    return out
+
+
+def _superset(hits: list[GraphEntry]) -> GraphEntry | None:
+    """When one match's roots contain every other match's roots, that graph is the combined one."""
+    if len(hits) < 2:
+        return None
+    sets = [(e, _root_set(e)) for e in hits]
+    strict = []
+    for entry, roots in sets:
+        if roots and all(other <= roots for other_entry, other in sets) and any(
+                other < roots for other_entry, other in sets if other_entry is not entry):
+            strict.append(entry)
+    return strict[0] if len(strict) == 1 else None
+
+
+def resolve(registry: Registry, *, graph: str | None, paths: list[str],
+            cwd: Path | None = None, mcp_roots: list[str] | None = None) -> GraphEntry:
+    """Pick a graph. Several matches stay an error unless one graph's roots contain the others."""
+    by = registry.by_name()
+    if graph:
+        if graph not in by:
+            raise GraphError(f"unknown graph {graph!r}; choices: {', '.join(registry.names())}")
+        return by[graph]
+    path_hits = [e for e in registry.entries if paths and _matches(e, paths)]
+    if len(path_hits) == 1:
+        return path_hits[0]
+    if len(path_hits) > 1:
+        chosen = _superset(path_hits)
+        if chosen is not None:
+            return chosen
+        raise _choice_error(path_hits)
+    places: list[str] = []
+    if mcp_roots:
+        places.extend(mcp_roots)
+    places.append(str(cwd or Path.cwd()))
+    loc_hits = [e for e in registry.entries if _matches(e, places)]
+    if len(loc_hits) == 1:
+        return loc_hits[0]
+    if len(loc_hits) > 1:
+        chosen = _superset(loc_hits)
+        if chosen is not None:
+            return chosen
+        raise _choice_error(loc_hits)
+    if registry.default and registry.default in by:
+        return by[registry.default]
+    if len(registry.entries) == 1:
+        return registry.entries[0]
+    raise _choice_error(registry.entries)
+
+
+def _languages(meta: dict) -> list[str]:
+    if isinstance(meta.get("languages"), list):
+        return [str(x) for x in meta["languages"]]
+    stats = meta.get("stats") or {}
+    found: list[str] = []
+    cov = stats.get("coverage") if isinstance(stats, dict) else None
+    if cov is None:
+        cov = meta.get("coverage")
+    blocks = []
+    if isinstance(cov, dict):
+        if isinstance(cov.get("languages"), list):
+            blocks.append(cov["languages"])
+        else:
+            for value in cov.values():
+                if isinstance(value, dict) and isinstance(value.get("languages"), list):
+                    blocks.append(value["languages"])
+    for block in blocks:
+        for item in block:
+            if isinstance(item, dict) and item.get("language"):
+                found.append(str(item["language"]))
+    if not found and isinstance(stats, dict):
+        det = (stats.get("detected") or {}).get("languages") or {}
+        if isinstance(det, dict):
+            found.extend(str(k) for k in det)
+    return sorted(set(found))
+
+
+def _commit_text(meta: dict) -> str:
+    commit = meta.get("commit")
+    if isinstance(commit, dict):
+        parts = [f"{k}={str(v)[:12]}" for k, v in commit.items() if v]
+        return ", ".join(parts)
+    if isinstance(commit, str) and commit:
+        return commit[:12]
+    return ""
+
+
+def _freshness(meta: dict, roots: list[Path]) -> str:
+    commit = meta.get("commit")
+    heads = [git_head(r) for r in roots]
+    heads = [h for h in heads if h]
+    if not commit or not heads:
+        return "unknown"
+    if isinstance(commit, dict):
+        vals = [str(v) for v in commit.values() if v]
+        if not vals:
+            return "unknown"
+        return "fresh" if all(v in heads for v in vals) else "stale"
+    return "fresh" if str(commit) in heads else "stale"
+
+
+def describe(entry: GraphEntry) -> dict:
+    """Name, roots, languages, indexed commit and freshness. Opens the DB briefly."""
+    meta: dict = {}
+    try:
+        st = GraphStore(entry.db)
+        try:
+            meta = st.meta()
+        finally:
+            st.db.close()
+    except Exception:
+        meta = {}
+    roots = entry.roots or ([Path(meta["root"])] if meta.get("root") else [])
+    return {
+        "name": entry.name,
+        "roots": [str(r) for r in roots],
+        "languages": _languages(meta),
+        "commit": _commit_text(meta),
+        "freshness": _freshness(meta, roots),
+    }
+
+
+def render_graphs(registry: Registry) -> str:
+    lines = [f"{len(registry.entries)} graph(s)" + (f" default={registry.default}" if registry.default else "")]
+    for entry in registry.entries:
+        info = describe(entry)
+        mark = " default" if registry.default == entry.name else ""
+        langs = ", ".join(info["languages"]) or "none"
+        roots = ", ".join(info["roots"]) or "(no roots)"
+        commit = info["commit"] or "unknown"
+        lines.append(f"{info['name']}{mark} roots: {roots} languages: {langs} "
+                     f"commit: {commit} freshness: {info['freshness']} db: {entry.db}")
+    return "\n".join(lines)