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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.22.0
+Version: 0.23.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

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

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

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

@@ -636,6 +636,8 @@ def main(argv=None):
         print(json.dumps(res, indent=1, default=str) if a.json else render_protocols(res, max_items=a.max_items))
         return
     if a.cmd == "tests":
+        if _unknown_route(st, a.spec, a.json):
+            return
         res = Q.tests_covering(st, a.spec, min_conf=a.min_confidence, near_depth=a.max_depth or None,
                                unit_only=a.unit_only, exclude_roots=a.exclude_root, through_roots=a.through_roots)
         res["completeness"] = _completeness(st, res.get("targets"))
@@ -674,12 +676,17 @@ def main(argv=None):
         print(json.dumps(res, indent=1, default=str) if a.json else Q.render_search(res))
         return
     if a.cmd == "reaches":
+        for spec in a.specs:
+            if _unknown_route(st, spec, a.json):
+                return
         res = Q.reaches(st, a.specs, min_conf=a.min_confidence, max_depth=a.max_depth, gate=None if a.gate == "none" else a.gate,
                         platform=a.platform, connection=a.connection)
         res["completeness"] = _completeness(st, [x for t in res["targets"].values() for x in t] + [i["id"] for i in res["items"]])
         print(json.dumps(res, indent=1, default=str) if a.json else Q.render_reaches(res, show_paths=not a.no_paths))
         _note(res["completeness"], a.json)
     elif a.cmd == "impact":
+        if _unknown_route(st, a.spec, a.json):
+            return
         res = Q.impact(st, a.spec, min_conf=a.min_confidence, platform=a.platform)
         if a.json:
             res["completeness"] = _completeness(st, list(res["targets"]) + [c["id"] for c in res["callers"]])
@@ -755,6 +762,8 @@ def main(argv=None):
         res = Q.siblings(st, a.spec)
         print(json.dumps(res, indent=1, default=str) if a.json else Q.render_siblings(st, a.spec, res))
     elif a.cmd == "node":
+        if _unknown_route(st, a.spec, a.json):
+            return
         ids = list(dict.fromkeys(Q.resolve_targets(st, a.spec)))[:20]
         docs = [node_doc(st, nid) for nid in ids]
         if a.json:
@@ -774,10 +783,14 @@ def main(argv=None):
         if not p:
             raise SystemExit(1)  # scripts can tell "no path" apart from a path
     elif a.cmd == "downstream":
+        if _unknown_route(st, a.spec, a.json):
+            return
         res = Q.downstream(st, a.spec, min_conf=a.min_confidence, max_depth=a.max_depth, gate=None if a.gate == "none" else a.gate,
                            platform=a.platform)
         print(json.dumps(res, indent=1, default=str) if a.json else Q.render_downstream(res, show_paths=not a.no_paths))
     elif a.cmd == "api-calls":
+        if _unknown_route(st, a.spec, a.json):
+            return
         rows = Q.api_calls(st, a.spec)
         print(json.dumps(rows, indent=1, default=str) if a.json else Q.render_api_calls(rows))
         if not a.json:
@@ -789,6 +802,17 @@ def main(argv=None):
         doc = stats_doc(st)
         print(json.dumps(doc, indent=1, default=str) if a.json else render_stats(st, doc))
 
+def _unknown_route(st, spec: str, as_json: bool) -> bool:
+    miss = Q.route_failure(st, spec)
+    if not miss:
+        return False
+    if as_json:
+        print(json.dumps({"error": miss["error"], "spec": miss["spec"], "suggestions": miss["suggestions"]}))
+    else:
+        print(miss["text"])
+    raise SystemExit(1)
+
+
 def node_doc(st, nid: str) -> dict:
     """One node with its attrs parsed and its outgoing / incoming edges (`cg node --json`, #75)."""
     n = dict(st.node(nid))

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

@@ -101,20 +101,67 @@ def _method_ok(cm: str, rm: str) -> bool:
     return cm in rms or "ANY" in rms or (cm == "HEAD" and "GET" in rms)
 
 
+_BASE_SEG = re.compile(r"^(api|v\d+)$", re.I)
+
+
 def suffix_candidates(path: str, routes: list[dict]):
-    """Origin unknown: align the client path with the END of route URIs (prefix assumed to be the base)."""
+    """Align the client path with the end of a route only when the dropped prefix is a base path (`api`, `v1`)."""
     cs = _segs(path)
     out = []
     for r in routes:
         us = _segs(r["uri"])
         if len(us) <= len(cs):
             continue
+        dropped = us[:len(us) - len(cs)]
+        if any(not _BASE_SEG.match(seg) for seg in dropped):
+            continue
         ok, info = match_path("/" + "/".join(cs), "/" + "/".join(us[len(us) - len(cs):]))
         if ok and info["lit"] > 0:
             out.append((r, "suffix", info))
     return out
 
 
+def known_origin_text(attrs: dict) -> str | None:
+    """Env placeholder or literal base URL, when the client recorded one."""
+    kind = attrs.get("origin_kind")
+    origin = attrs.get("origin") or ""
+    base = attrs.get("base") or {}
+    if not isinstance(base, dict):
+        base = {}
+    parts = [origin, base.get("placeholder") or "", base.get("value") or ""]
+    text = " ".join(p for p in parts if isinstance(p, str) and p)
+    if kind == "env" or (isinstance(origin, str) and origin.startswith("{env.")):
+        return text or None
+    if kind == "other" or "://" in text:
+        return text or None
+    return None
+
+
+_GENERIC_ORIGIN = {"env", "base", "url", "api", "app", "http", "https", "host", "origin", "endpoint", "service", "internal"}
+
+
+def repos_for_origin(text: str, servers: list[str]) -> list[str] | None:
+    """Server names named by the origin.
+
+    ``None`` when the origin is a generic API base (``API_BASE_URL``) and does not name a repo:
+    matching stays as it was. ``[]`` when it names a service that is not one of ``servers``.
+    """
+    low = text.lower()
+    hits = []
+    for name in servers:
+        token = name.lower()
+        if len(token) < 3:
+            continue
+        if re.search(rf"(^|[^a-z0-9]){re.escape(token)}([^a-z0-9]|$)", low):
+            hits.append(name)
+    if hits:
+        return hits
+    tokens = [t for t in re.findall(r"[a-z][a-z0-9]+", low) if t not in _GENERIC_ORIGIN]
+    if not tokens:
+        return None
+    return []
+
+
 def match_endpoint(method: str, path: str, routes: list[dict], origin_kind: str = "api", origin: str | None = None,
                    base_prefix: str | None = None) -> dict:
     """base_prefix: path part of a configured base URL already folded into `path` (http node attrs.base); when the
@@ -388,7 +435,15 @@ def link_many(repos: list[tuple[str, str, str]], out_db: str, *, allow: dict | N
         targets = [s for s in server_names if (s != client or folded_self) and (client not in allow or s in allow[client])]
         pool = [rt for s in targets for rt in by_server[s]]
         bp = base_path((a.get("base") or {}).get("value") or "") if a.get("base") else None
+        origin_text = known_origin_text(a)
+        owners = repos_for_origin(origin_text, targets) if origin_text else None
+        if owners is not None and len(owners) == 1:
+            pool = [rt for rt in pool if rt["server"] == owners[0]]
         res = match_endpoint(a["method"], a["path"], pool, a.get("origin_kind", "api"), a.get("origin"), base_prefix=bp or None)
+        if origin_text and owners == [] and not res.get("matched") and a.get("origin_kind") != "other":
+            reason = res.get("reason") or ""
+            if reason.startswith(("no backend route", "not a backend URL")) or "suffix" in reason:
+                res["reason"] = "external (other origin)"
         res.update({"endpoint": ep_id, "method": a["method"], "calls": calls_by_ep.get(ep_id, []),
                     "_client": client, "_servers": targets})
         results.append(res)
@@ -448,13 +503,20 @@ def link_many(repos: list[tuple[str, str, str]], out_db: str, *, allow: dict | N
     for sc in scen[:1]:
         db.executemany("INSERT INTO node_entry_live VALUES (?,?,?,?,?)", [(sc, *r) for r in tag_entries_rows(nodes, edges, prop, skip_gate=sc)])
     db.commit()
+    # call sites whose wrapper no entry point reaches are matched, but not live
+    live_ids = {r[0] for r in db.execute("SELECT DISTINCT node_id FROM node_entry WHERE entry_kind != 'test'")}
+    for r in results:
+        for c in r["calls"]:
+            c["live"] = c.get("src") in live_ids
+        if r["matched"] and r["calls"] and not any(c.get("live") for c in r["calls"]):
+            r["no_live_caller"] = True
     # ---- stats: per call site and per distinct endpoint
     n_ep = len(results)
     m_ep = sum(1 for r in results if r["matched"])
     site_match = {}
     for r in results:
         for c in r["calls"]:
-            site_match[c["at"]] = site_match.get(c["at"], False) or bool(r["matched"])
+            site_match[c["at"]] = site_match.get(c["at"], False) or (bool(r["matched"]) and c.get("live", True))
     sites = list(site_match)
     m_sites = sum(1 for v in site_match.values() if v)
     conf_ct = defaultdict(int)
@@ -476,7 +538,7 @@ def link_many(repos: list[tuple[str, str, str]], out_db: str, *, allow: dict | N
             for r in eps:
                 hit = any(rmap[m["route"]]["server"] == server for m in r["matched"])
                 for c in r["calls"]:
-                    sm[c["at"]] = sm.get(c["at"], False) or hit
+                    sm[c["at"]] = sm.get(c["at"], False) or (hit and c.get("live", True))
             pair_stats.append({"client": client, "server": server, "endpoints": len(eps),
                                "endpoints_matched": sum(1 for r in eps if any(rmap[m["route"]]["server"] == server for m in r["matched"])),
                                "call_sites": len(sm), "call_sites_matched": sum(1 for v in sm.values() if v)})
@@ -667,6 +729,11 @@ def write_match_report(res: dict, out_prefix: str) -> None:
         at = ", ".join(sorted({c["at"] for c in r["calls"]})[:3])
         extra = f" closest={r['closest']}" if r.get("closest") else (f" near={r['near']}" if r.get("near") else "")
         L.append(f"- `{r['endpoint']}` - {r['reason']}{extra} - at {at}")
+    dead = [r for r in res["results"] if r.get("no_live_caller")]
+    if dead:
+        L += ["", "## Matched, no live caller", ""]
+        for r in dead:
+            L.append(f"- `{r['endpoint']}` — matched, no live caller")
     L += ["", "## Ambiguous / heuristic matches", ""]
     for r in res["results"]:
         if r["matched"] and (len(r["matched"]) > 1 or any(m["confidence"] == "heuristic" for m in r["matched"])):

{cg_code_graph-0.22.0 → cg_code_graph-0.23.0}/cg_code_graph/mcp_graphs.py

@@ -68,7 +68,7 @@ def git_head(root: Path) -> str | None:
 
 
 def _valid_name(name: str) -> bool:
-    return bool(name) and all(c.isalnum() or c in "_.-" for c in name)
+    return bool(name) and all(c.isalnum() or c in "_.-+" for c in name)   # `app+api`: a combined graph
 
 
 def parse_db_arg(text: str) -> tuple[str, Path]:
@@ -318,9 +318,58 @@ def _superset(hits: list[GraphEntry]) -> GraphEntry | None:
     return strict[0] if len(strict) == 1 else None
 
 
+def _deepest_repo(hits: list[GraphEntry], texts: list[str]) -> Path | None:
+    """The repo containing the path: the deepest matching root, when that root is unique."""
+    containing: list[Path] = []
+    for entry in hits:
+        for root in entry.roots:
+            if not any(_under(root, text) for text in texts):
+                continue
+            try:
+                containing.append(root.expanduser().resolve())
+            except OSError:
+                containing.append(root)
+    if not containing:
+        return None
+    deepest: list[Path] = []
+    for root in containing:
+        if any(other != root and _under(root, str(other)) for other in containing):
+            continue
+        deepest.append(root)
+    unique = set(deepest)
+    if len(unique) != 1:
+        return None
+    return next(iter(unique))
+
+
+def _own_graph(hits: list[GraphEntry], texts: list[str]) -> GraphEntry | None:
+    """The one match whose roots are exactly the repo that contains the path."""
+    repo = _deepest_repo(hits, texts)
+    if repo is None:
+        return None
+    own = [entry for entry in hits if _root_set(entry) == {repo}]
+    return own[0] if len(own) == 1 else None
+
+
+def _pick(registry: Registry, hits: list[GraphEntry], texts: list[str]) -> GraphEntry:
+    """Superset, then the graph that is only that repo, then the configured default."""
+    chosen = _superset(hits)
+    if chosen is not None:
+        return chosen
+    chosen = _own_graph(hits, texts)
+    if chosen is not None:
+        return chosen
+    if registry.default:
+        by = registry.by_name()
+        default = by.get(registry.default)
+        if default is not None and default in hits:
+            return default
+    raise _choice_error(hits)
+
+
 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."""
+    """Pick a graph. Several matches use a superset, then a single-repo graph, then the default."""
     by = registry.by_name()
     if graph:
         if graph not in by:
@@ -330,10 +379,7 @@ def resolve(registry: Registry, *, graph: str | None, paths: list[str],
     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)
+        return _pick(registry, path_hits, paths)
     places: list[str] = []
     if mcp_roots:
         places.extend(mcp_roots)
@@ -342,10 +388,7 @@ def resolve(registry: Registry, *, graph: str | None, paths: list[str],
     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)
+        return _pick(registry, loc_hits, places)
     if registry.default and registry.default in by:
         return by[registry.default]
     if len(registry.entries) == 1:

{cg_code_graph-0.22.0 → cg_code_graph-0.23.0}/cg_code_graph/mcp_server.py

@@ -302,6 +302,11 @@ def _run_call(fn, args, kwargs) -> tuple[str, dict]:
             return str(ex), {"complete": False, "recorded": False, "languages": {}}
         _CALL.set({"graph_entry": entry, "graph_name": entry.name, "db": str(Path(entry.db).resolve())})
         named = entry.name
+        if entry.tools and str(entry.tools).strip():
+            allowed = set(selected_tool_names(entry.tools, warn=False))
+            if fn.__name__ not in allowed:
+                return (f"tool {fn.__name__} is not allowed for graph {entry.name}",
+                        {"complete": False, "recorded": False, "languages": {}})
     token, ptoken, xtoken = _SCOPE.set(None), _PF.set(None), _EXTRA.set(None)
     try:
         try:
@@ -315,7 +320,7 @@ def _run_call(fn, args, kwargs) -> tuple[str, dict]:
         _SCOPE.reset(token)
         _PF.reset(ptoken)
         _EXTRA.reset(xtoken)
-    if named and isinstance(txt, str) and not txt.startswith(("ambiguous graph:", "unknown graph ")):
+    if named and isinstance(txt, str) and not txt.startswith(("ambiguous graph:", "unknown graph ", "tool ")):
         txt = f"graph {named}\n" + txt
     comp = _completeness(scope)
     if pf:
@@ -481,6 +486,9 @@ def reaches(targets: list[str], min_confidence: str = "heuristic", group_by: str
     if pf and res["platform"].get("targets_not_built"):
         pline.append(f"not built for {pf}: {', '.join(short(t) for t in res['platform']['targets_not_built'][:6])}")
     if missing and len(missing) == len(res["targets"]):
+        route_lines = [Q.route_failure(st, s)["text"] for s in missing if Q.route_failure(st, s)]
+        if route_lines and len(route_lines) == len(missing):
+            return "\n".join(route_lines)
         return "\n".join(pline + [f"targets: {tl}"]) + f"\nno node matches {', '.join(map(repr, missing))}; try search() with part of the name (spec forms are listed in the server instructions)"
     if not items and connection:
         return "\n".join(pline + [f"targets: {tl}", f"no dependents recorded for {', '.join(res['targets'])} on connection {connection!r} "
@@ -558,6 +566,9 @@ def impact(method: str, min_confidence: str = "heuristic", max_items: int = 60,
             if Q.divergence_lists(st, pf, dropped):
                 msg += f"; platform_divergence(target='{pf}') lists references to it that would not build"
             return "\n".join(pline + [msg])
+        miss = Q.route_failure(st, method)
+        if miss:
+            return miss["text"]
         return f"no method matches {method!r}; try search() with part of the name"
     _scope(list(r["targets"]) + [c["id"] for c in r["callers"]])
     if pf and set(r["platform"]["targets_not_built"]) == set(r["targets"]):
@@ -996,7 +1007,11 @@ def tests_covering(target: str, min_confidence: str = "heuristic", paths: bool =
     classes, exclude_roots symbols; through_roots=true keeps them). UI / snapshot / screenshot tests (XCUITest,
     Compose UI / Espresso, Playwright / Cypress, *UITests / androidTest folders) are listed apart, or left out
     with unit_only=true. The summary line counts what was left out and why."""
-    res = Q.tests_covering(_st(), target, min_conf=min_confidence, near_depth=max_depth or None, unit_only=unit_only,
+    st = _st()
+    miss = Q.route_failure(st, target)
+    if miss:
+        return miss["text"]
+    res = Q.tests_covering(st, target, min_conf=min_confidence, near_depth=max_depth or None, unit_only=unit_only,
                            exclude_roots=exclude_roots, through_roots=through_roots)
     _scope(res.get("targets") or [])
     return Q.render_tests_covering(res, show_paths=paths)
@@ -1239,6 +1254,9 @@ def downstream(target: str, max_per_kind: int = 25, paths: bool = True, min_conf
     pf, pline = _platform(st, platform)
     r = Q.downstream(st, target, min_conf=min_confidence, platform=pf)
     if not r["targets"]:
+        miss = Q.route_failure(st, target)
+        if miss:
+            return miss["text"]
         return f"no node matches {target!r}; try search()"
     out = pline + [f"targets: {', '.join(short(t) for t in r['targets'][:4])} | reached {r['reached']} nodes | gate={r.get('gate')}"]
     if not r["sinks"]:
@@ -1328,8 +1346,14 @@ def api_calls(filter: str = "all", max_items: int = 60) -> str:
     """Frontend HTTP calls (method + path template) with call sites, request keys and the matched backend
     route + controller (combined graph). filter: all | unmatched | any substring (endpoint, route, caller, file) |
     a `*` glob (`GET /v1/*/orders*`, `*/staff/*`, `*useOrders*`) on the endpoint, its path, route, controller,
-    caller or call-site file."""
+    caller or call-site file. `route:VERB /path` is an exact route match (verb case-insensitive; `:id`, `{id}` and
+    `{order}` match one param segment). `route:POST /payments/*` or `route:* /payments` widens it. An unknown
+    route returns `no such route` and the nearest routes. A call site with no entry point is marked
+    `(no live caller)` and `filter='dead'` lists matched endpoints with no live call site."""
     st = _st()
+    miss = Q.route_failure(st, filter)
+    if miss:
+        return miss["text"]
     rows = Q.api_calls(st, filter)
     gaps = defaultdict(list)
     for g in Q.forwarding_gaps(st):
@@ -1618,12 +1642,12 @@ def _tool_names() -> list[str]:
     return [t.name for t in server._tool_manager.list_tools()]
 
 
-def apply_tool_allowlist(spec: str) -> list[str]:
-    """Keep only the tools selected by spec and return their names.
+def selected_tool_names(spec: str, *, warn: bool = True) -> list[str]:
+    """Names selected by a tool spec, in server order. Does not change the listed set.
 
     Items are comma- or space-separated. `all` is every tool, `core` is the reading set,
     a name or fnmatch glob adds tools, and a leading `-` removes them (`all,-plan_*`).
-    Unknown names are warned once on stderr and ignored. An empty selection exits 2.
+    Unknown names are warned once on stderr and ignored.
     """
     import fnmatch
     names = _tool_names()
@@ -1652,18 +1676,52 @@ def apply_tool_allowlist(spec: str) -> list[str]:
             selected -= matched
         else:
             selected |= matched
-    if unknown:
+    if warn and unknown:
         print("cg-mcp: CG_MCP_TOOLS: unknown name(s): " + ", ".join(unknown), file=sys.stderr)
-    kept = [n for n in names if n in selected]
+    return [n for n in names if n in selected]
+
+
+def registry_tool_spec(registry) -> str | None:
+    """Union of per-graph allowlists. ``None`` means at least one graph lists every tool."""
+    specs = [e.tools for e in registry.entries if e.tools and str(e.tools).strip()]
+    if len(specs) != len(registry.entries):
+        return None
+    names: list[str] = []
+    seen: set[str] = set()
+    for spec in specs:
+        for name in selected_tool_names(spec, warn=False):
+            if name not in seen:
+                seen.add(name)
+                names.append(name)
+    return ",".join(names) if names else None
+
+
+def apply_tool_allowlist(spec: str) -> list[str]:
+    """Keep only the tools selected by spec and return their names.
+
+    An empty selection exits 2.
+    """
+    kept = selected_tool_names(spec)
     if not kept:
         print("cg-mcp: CG_MCP_TOOLS selects no tools", file=sys.stderr)
         raise SystemExit(2)
-    for name in names:
+    selected = set(kept)
+    for name in _tool_names():
         if name not in selected:
             server.remove_tool(name)
     return kept
 
 
+def apply_registry_tools(registry, server_tools: str | None = None) -> list[str] | None:
+    """List one fixed set: ``server_tools`` when given, otherwise the union of per-graph allowlists."""
+    if server_tools:
+        return apply_tool_allowlist(server_tools)
+    spec = registry_tool_spec(registry)
+    if spec is None:
+        return None
+    return apply_tool_allowlist(spec)
+
+
 def expose_graph_argument() -> None:
     """Add optional `graph` to every tool schema. Single-`--db` mode leaves the schemas unchanged."""
     if STATE.get("graph_arg"):
@@ -1700,6 +1758,8 @@ def configure(*, dbs: list[str] | None = None, db_dir: str | None = None, graphs
     STATE["registry"] = reg
     STATE["db"] = str(Path(reg.entries[0].db).resolve())
     expose_graph_argument()
+    if not STATE.get("server_tools"):
+        apply_registry_tools(reg)
 
 
 def _install_roots_hook() -> None:
@@ -1771,8 +1831,11 @@ def main(argv=None):
         STATE["registry"] = reg
         STATE["db"] = str(Path(reg.entries[0].db).resolve())
         expose_graph_argument()
+    STATE["server_tools"] = a.tools or None
     if a.tools:
         apply_tool_allowlist(a.tools)
+    elif STATE.get("multi"):
+        apply_registry_tools(STATE["registry"])
     server.run("stdio")