cg-code-graph 0.23.1__tar.gz → 0.23.3__tar.gz

{cg_code_graph-0.23.1/cg_code_graph.egg-info → cg_code_graph-0.23.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.23.1
+Version: 0.23.3
 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
@@ -18,7 +18,7 @@ Requires-Dist: tree-sitter-c>=0.23
 Requires-Dist: tree-sitter-cpp>=0.23
 Requires-Dist: tree-sitter-kotlin>=1.0
 Requires-Dist: tree-sitter-java>=0.23
-Requires-Dist: tree-sitter-swift<0.7.4,>=0.6
+Requires-Dist: tree-sitter-swift<0.8,>=0.6
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Provides-Extra: watch

{cg_code_graph-0.23.1 → cg_code_graph-0.23.3}/cg_code_graph/__init__.py

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

{cg_code_graph-0.23.1 → cg_code_graph-0.23.3}/cg_code_graph/cli.py

@@ -100,9 +100,24 @@ def _impact_labels(rows: list[dict], name_of, group_of) -> list[str]:
     return labels
 
 
+def _version_text(version: str) -> str:
+    """`cg X.Y.Z`, plus a second line when the cached newer-release check (written by `cg doctor`) knows of a newer
+    release. Reads the cache only: never connects (#98)."""
+    try:
+        from .update_check import check, notice
+        n = notice(check(version, network=False))
+    except Exception:
+        n = None
+    return f"cg {version}" + (f"\n{n}" if n else "")
+
+
 def main(argv=None):
     from . import __version__
     ap = argparse.ArgumentParser(prog="cg")
+    args_in = sys.argv[1:] if argv is None else list(argv)
+    if args_in[:1] == ["--version"]:
+        print(_version_text(__version__))   # printed here: argparse's version action re-wraps a second line
+        return 0
     ap.add_argument("--version", action="version", version=f"cg {__version__}")
     sub = ap.add_subparsers(dest="cmd", required=True)
     p = sub.add_parser("index", help="detect languages / frameworks under ROOT and build the graph DB (stats JSON on stdout, coverage on stderr)"); p.add_argument("root"); p.add_argument("--db", required=True); p.add_argument("--name"); p.add_argument("--scip", action="append"); p.add_argument("--gates", help="gate scenarios JSON (e.g. examples/bookstore.gates.json)")
@@ -718,7 +733,8 @@ def main(argv=None):
             print(Q.connections_line(res["connections"]))
         if not res["callers"] and not res["entry_points"]:
             print(Q.explain_no_callers(st, a.spec, res["targets"], a.min_confidence)); return
-        print(f"callers (transitive): {len(res['callers'])}")
+        nc = res.get("callers_candidate") or 0
+        print(f"callers (transitive): {len(res['callers']) - nc}" + (f" (+{nc} candidate)" if nc else ""))
         caller_names = _impact_labels(res["callers"], lambda c: c.get("fqn") or c["id"], lambda c: c.get("module") or c.get("kind"))
         for c, nm in zip(res["callers"], caller_names):
             loc = f"  @ {c['file']}:{c['line']}" if Q.NATIVE_FILE_RE.search(c.get("file") or "") else ""
@@ -862,6 +878,11 @@ def render_node(d: dict) -> str:
         unk = at.get("platform_unknown") or []
         ps = ", ".join(p + ("?" if p in unk else "") for p in at["platforms"]) or "none of the targets"
         out.append(f"  platforms: {ps}" + (f"  ({at['platform_expr']})" if at.get("platform_expr") else ""))
+    if n.get("kind") == "i18n" and at.get("definitions"):
+        out.append("  definitions: " + ", ".join(f"{x.get('locale') or '-'} {x['file']}:{x['line']}" for x in at["definitions"]))
+        if at.get("missing_locales"):
+            out.append("  missing locales: " + ", ".join(at["missing_locales"]))
+        at = {k: v for k, v in at.items() if k not in ("definitions", "defined_in", "missing_locales")}
     rest = {k: v for k, v in at.items() if k not in ("platforms", "platform_unknown", "platform_expr", "platform_at", "platforms_other")}
     if rest:
         out.append("  attrs: " + ", ".join(f"{k}={v if isinstance(v, str) else json.dumps(v, default=str, ensure_ascii=False)}"

{cg_code_graph-0.23.1 → cg_code_graph-0.23.3}/cg_code_graph/core/model.py

@@ -56,7 +56,7 @@ EDGE_KINDS: dict[str, tuple[bool, str]] = {
     "HTTP_CALLS": (True, "client code calls an HTTP endpoint (method + path template)"),
     "MATCHES_ROUTE": (True, "client endpoint matched to a backend route (cross-repo link)"),
     "USES_LAYOUT": (False, "page uses layout"),
-    "USES_I18N": (False, "code/template uses i18n key"),
+    "USES_I18N": (True, "code/template uses i18n key (propagating: a key's users are its dependents in reaches / impact, #182)"),
     "REFERENCES_TYPE": (False, "code references a type/interface"),
     # value facts
     "READS_SETTING": (True, "code reads a JSON settings key (getSetting('a.b', default))"),

{cg_code_graph-0.23.1 → cg_code_graph-0.23.3}/cg_code_graph/doctor.py

@@ -407,12 +407,25 @@ def report(root: str | Path | None = None, scip: list | None = None) -> dict:
         "legacy_cache": cache.legacy_report(),
         **({"hooks_outdated": _outdated_hooks(rootp)} if rootp is not None else {}),
         "update": "uv tool upgrade cg-code-graph  |  pipx upgrade cg-code-graph  |  install.sh --update",
+        "latest": _latest(),
         **({"scip": [scip_health(x) for x in scip]} if scip else {}),
     }
 
 
+def _latest() -> dict:
+    """Newer-release check (#98): PyPI at most once a day, cached; never fails or blocks for long."""
+    from .update_check import check
+    try:
+        return check()
+    except Exception:
+        return {"current": __version__, "latest": None, "newer": False, "source": "none", "disabled": None}
+
+
 def render(r: dict) -> str:
     out = [f"cg {r['cg']}  (Python {r['python']}, {r['os']}; {r['package']}{', checkout' if r['checkout'] else ''})"]
+    from .update_check import notice
+    if (n := notice(r.get("latest") or {})):
+        out.append(f"newer release: {n}")
     out.append("tools:")
     for k, v in r["tools"].items():
         out.append(f"  {k:<14} {v['version'] or 'not found'}" + (f"  ({v['path']})" if v["path"] else "")

{cg_code_graph-0.23.1 → cg_code_graph-0.23.3}/cg_code_graph/mcp_server.py

@@ -601,7 +601,9 @@ def impact(method: str, min_confidence: str = "heuristic", max_items: int = 60,
     dropped_line = [f"not built for {pf}: {', '.join(short(t) for t in dropped[:6])}"] if pf and dropped else []
     out = pline + dropped_line + [f"targets: {', '.join(short(t) for t in r['targets'][:5])}", *via_default, *Q.override_lines(r),
                    *([Q.connections_line(r["connections"])] if r.get("connections") else []),
-                   f"transitive callers: {len(r['callers'])}; entry points: {len(r['entry_points'])}"]
+                   f"transitive callers: {r.get('callers_resolved', len(r['callers']))}"
+                   + (f" (+{r['callers_candidate']} candidate)" if r.get("callers_candidate") else "")
+                   + f"; entry points: {len(r['entry_points'])}"]
     if not r["callers"] and not r["entry_points"]:
         return "\n".join(out + [Q.explain_no_callers(st, method, r["targets"], min_confidence)])
     byk = defaultdict(list)
@@ -619,7 +621,7 @@ def impact(method: str, min_confidence: str = "heuristic", max_items: int = 60,
             out.append(f"  {lab}{Q.CANDIDATE_LABEL if e.get('candidate') else ''}{Q.platform_label(e)}{hop}")
     bymod = defaultdict(list)
     for c in r["callers"]:
-        bymod[c.get("module") or "?"].append(c)
+        bymod[Q.caller_group(c)].append(c)
     dup_lines = []
     for mod in sorted(bymod):
         cs = bymod[mod]
@@ -631,8 +633,10 @@ def impact(method: str, min_confidence: str = "heuristic", max_items: int = 60,
         out.append("same name in one module: " + "; ".join(dup_lines))
     mods = defaultdict(int)
     for c in r["callers"]:
-        mods[c.get("module") or "?"] += 1
-    out.append("\ncallers by module: " + ", ".join(f"{m}×{c}" for m, c in sorted(mods.items(), key=lambda x: -x[1])))
+        if not c.get("candidate"):          # candidates are listed on their own below (#204)
+            mods[Q.caller_group(c)] += 1
+    if mods:
+        out.append("\ncallers by module: " + ", ".join(f"{m}×{c}" for m, c in sorted(mods.items(), key=lambda x: -x[1])))
     gen = [c for c in r["callers"] if c.get("generated")]
     if gen:    # indexed with --include-generated: callers in files a generator writes
         out.append(f"in generated / copied files ({len(gen)}): " + ", ".join(f"{short(c['id'])} [{c['generated']}]" for c in gen[:8])
@@ -648,8 +652,13 @@ def impact(method: str, min_confidence: str = "heuristic", max_items: int = 60,
                                                              for c in vo[:8]) + (f" …+{len(vo) - 8}" if len(vo) > 8 else ""))
     cand = [c for c in r["callers"] if c.get("candidate")]
     if cand or any(e.get("candidate") for e in r["entry_points"]):   # reached through a candidate call edge (#83)
-        out.append(f"candidate callers ({len(cand)}): " + ", ".join(short(c["id"]) for c in cand[:12])
+        out.append(f"candidate callers ({len(cand)}): " + ", ".join(short(c["id"]) + Q.fanout_text(c) for c in cand[:12])
                    + (f" …+{len(cand) - 12}" if len(cand) > 12 else "") + "\n" + Q.CANDIDATE_NOTE)
+    od = [c for c in r["callers"] if c.get("omits_default")]
+    if od:     # calls that leave out a defaulted argument and so run its default (#212)
+        out.append(f"through an omitted default argument ({len(od)}): "
+                   + ", ".join(f"{short(c['id'])} ({c['omits_default']}: of {short(c.get('default_of'))})" for c in od[:8])
+                   + (f" …+{len(od) - 8}" if len(od) > 8 else ""))
     vb = [c for c in r["callers"] if c.get("via_base")]
     if vb:     # calls the base declaration; the target is reached through the override
         out.append(f"via base ({len(vb)}): " + ", ".join(f"{short(c['id'])} -> {c['via_base']}" for c in vb[:8])
@@ -702,12 +711,26 @@ def callers(symbol: str, min_confidence: str = "heuristic", limit: int = 60) ->
     if not rows:
         return head + f"\nno direct callers of {symbol!r} in indexed code (min_confidence={min_confidence}). try: impact() for " \
                       f"entry points, reaches() for every dependent over all edge kinds, node() for its other edges"
-    out = [head, f"direct callers: {len({r['src'] for r in rows})} ({len(rows)} sites)"]
-    for r in rows[:limit]:
+    # one row per call site: a site linked to several per-platform definitions of the target is one site (#201)
+    seen, uniq = set(), []
+    for r in rows:
+        if (r["src"], r["kind"], r["file"], r["line"]) not in seen:
+            seen.add((r["src"], r["kind"], r["file"], r["line"]))
+            uniq.append(r)
+    rows = uniq
+    is_cand = [bool(r["attrs"] and '"binding": "candidate"' in r["attrs"]) for r in rows]
+    res = [r for r, cd in zip(rows, is_cand) if not cd]
+    cands = [r for r, cd in zip(rows, is_cand) if cd]
+    # selector-only candidates (receiver type unknown) are counted apart from resolved callers (#204)
+    out = [head, f"direct callers: {len({r['src'] for r in res})} ({len(res)} sites)"
+           + (f"; candidate callers: {len({r['src'] for r in cands})} ({len(cands)} site{'' if len(cands) == 1 else 's'}, receiver type unknown)"
+              if cands else "")]
+    for r in (res + cands)[:limit]:
         c = "" if r["confidence"] == "exact" else f" ~{r['confidence'][0]}"
         k = "ref" if r["kind"] == "REFERENCES_FN" else r["kind"]
-        cand = Q.CANDIDATE_LABEL if r["attrs"] and '"binding": "candidate"' in r["attrs"] else ""
-        out.append(f"  {short(r['src'])}  {k}@{at((r['file'] or '?') + ':' + str(r['line']))}{c}{cand}")
+        cand = Q.candidate_label(r["attrs"], r["dst"]) if r in cands else ""
+        out.append(f"  {short(r['src'])}  {k}@{at((r['file'] or '?') + ':' + str(r['line']))}{c}{cand}"
+                   + Q.omitted_default_label(r["attrs"]))
     if len(rows) > limit:
         out.append(f"  … +{len(rows) - limit} more (raise limit)")
     return "\n".join(out)
@@ -1086,7 +1109,8 @@ def node(id_or_symbol: str) -> str:
             for k, v in sorted(byk.items()):
                 if k == "CONTAINS":
                     continue
-                s = "; ".join(f"{short(r['o'])}@{r['line']}{'!g' if r['gate'] else ''}" for r in v[:6])
+                # `<id> :<line>`: a variant id carries its own `@N` (`refreshStatus@24 :12`, #201)
+                s = "; ".join(f"{short(r['o'])} :{r['line']}{'!g' if r['gate'] else ''}" for r in v[:6])
                 out.append(f"  {k}: {s}{' …' if len(v) > 6 else ''}")
     return "\n".join(out)
 

{cg_code_graph-0.23.1 → cg_code_graph-0.23.3}/cg_code_graph/platforms.py

@@ -29,6 +29,7 @@ on any target follow the implementation that target builds.
 """
 from __future__ import annotations
 
+import dataclasses
 import fnmatch
 import json
 import os
@@ -658,11 +659,13 @@ def apply(project, builder) -> dict:
                 etag[k] = hit
     targets, tsrc = declared_targets(root, cfg, marks, set(langs) | ({"c_cpp"} if langs & {"c", "cpp"} else set()))
     _write_attrs(builder, ntag, nvals, etag, targets)
+    narrowed = _narrow_variant_edges(builder, nvals, etag)
     _variant_platforms(builder, nvals, targets)
     unknown = [m for m in marks if any(m["cond"].values().get(p) is None for p in targets)]
     tagged_files = sorted({m["file"] for m in marks})
     st = {"targets": targets, "target_sources": tsrc, "conditions": len(marks), "files_with_conditions": len(tagged_files),
-          "tagged_nodes": len(ntag), "tagged_edges": len(etag), "variant_edges": mirrored, "text_scanned_files": scanned,
+          "tagged_nodes": len(ntag), "tagged_edges": len(etag), "variant_edges": mirrored,
+          "variant_edges_narrowed": narrowed, "text_scanned_files": scanned,
           "unevaluated_conditions": len(unknown),
           "unevaluated_per_target": {p: sum(1 for m in unknown if m["cond"].values().get(p) is None) for p in targets},
           "unevaluated_samples": sorted({f"{m['cond'].text} @ {m['file']}:{m['line']}" for m in unknown})[:8]}
@@ -824,6 +827,63 @@ def _write_attrs(builder, ntag, nvals, etag, targets=None) -> None:
             put(e.attrs, ms, _combine([m["cond"].values() for m in ms]))
 
 
+def _narrow_variant_edges(builder, nvals: dict, etag: dict) -> int:
+    """A reference made where only some targets build (`#if os(macOS)` around the caller or the call) reaches only the
+    per-platform definitions built on one of those targets (#201): a macOS-only call of `refreshStatus()` links the
+    macOS definition, not the `#else` stub. A reference whose definition is not built anywhere the site is moves to the
+    sibling definitions that are (the `#else` type's `Self()` names its own type), and a Swift `init` of a sibling
+    variant type that declares no initializer of its own (the implicit one) is no reference at all. References from
+    code built everywhere keep linking every definition."""
+    alts = {}
+    for ids in _alt_groups(builder, nvals).values():
+        if len(ids) > 1 and any(i in nvals for i in ids):
+            for i in ids:
+                alts[i] = ids
+    inits: dict[str, list] = defaultdict(list)       # Swift type -> its init nodes
+    parent: dict[str, str] = {}
+    for e in builder.edges.values():
+        if e.kind == "CONTAINS" and e.src.startswith("class:"):
+            parent[e.dst] = e.src
+            dn = builder.nodes.get(e.dst)
+            if dn is not None and dn.name == "init":
+                inits[e.src].append(e.dst)
+
+    def avail(i):
+        return {p for p in KNOWN if _avail(nvals.get(i), p)}
+
+    drop, adds = [], []
+    for k, e in builder.edges.items():
+        if e.kind in ("CONTAINS", "DEFINES", "GATED_BY"):
+            continue
+        vals = ([nvals[e.src]] if e.src in nvals else []) + [m["cond"].values() for m in etag.get(k, ())]
+        if not vals:
+            continue
+        site = {p for p, v in _combine(vals).items() if v is not False}
+        if not site or avail(e.dst) & site:
+            continue
+        ids = alts.get(e.dst)
+        if ids:
+            other = [i for i in ids if i != e.dst and avail(i) & site]
+            if other:
+                drop.append(k)
+                adds += [(e, i) for i in other]
+            continue
+        dn = builder.nodes.get(e.dst)
+        if dn is None or dn.lang != "swift" or dn.name != "init" or e.dst not in parent:
+            continue
+        own = parent[e.dst]
+        sib = [v for v in alts.get(own) or () if v != own and avail(v) & site]
+        if sib and all(not inits.get(v) for v in sib):
+            drop.append(k)                       # the sibling variant type's implicit initializer
+    for k in drop:
+        builder.edges.pop(k, None)
+    for e, nid in adds:
+        key = (e.src, nid, e.kind, e.file, e.line, e.gate)
+        if key not in builder.edges:
+            builder.edges[key] = dataclasses.replace(e, dst=nid, attrs={**(e.attrs or {}), "platform_variant_of": e.dst})
+    return len(drop)
+
+
 def _variant_platforms(builder, nvals: dict, targets) -> int:
     """A reference into one of a symbol's per-platform definitions (Rust / C / C++ / Swift `#if` branches) carries
     `variant_platforms`: the targets that definition is built for. Every definition is linked (_mirror), so a caller