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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.23.1
+Version: 0.23.2
 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.23.1 → cg_code_graph-0.23.2}/cg_code_graph/__init__.py

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

{cg_code_graph-0.23.1 → cg_code_graph-0.23.2}/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)")
@@ -862,6 +877,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.2}/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.2}/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.2}/cg_code_graph/plugins/nuxt/plugin.py

@@ -11,7 +11,9 @@ register_hooks: finds the source dir (nuxt.config `srcDir`, else `app/` (Nuxt 4)
   say which one was used (`prepared`: nuxi | generated).
 contribute: file-based routing (route path per page), entry points (pages = ui_page; app.vue,
   layouts, global middleware, plugins = ui_global), USES_LAYOUT, i18n keys (USES_I18N; defining
-  locale files).
+  locale files), Nitro server routes (server/api/** -> `route:<METHOD> /api/...`, server/routes/** without the
+  prefix; ROUTES_TO the default-export handler, USES_MIDDLEWARE every server/middleware handler, MATCHES_ROUTE
+  from same-origin $fetch / useFetch / useLazyFetch calls of the app) (#216).
 """
 from __future__ import annotations
 
@@ -851,6 +853,229 @@ def generate_types(root: Path, src_dir: str) -> tuple[Path, dict]:
                "import_scan": plan["scan"], "import_global": plan["global"], "auto_import": plan["auto_import"]}
 
 
+# Nitro file-based routing (https://nitro.build/guide/routing): <name>[.<method>][.<env>].<ext>
+NITRO_METHODS = ("get", "post", "put", "patch", "delete", "head", "options", "connect", "trace")
+_NITRO_EXT = re.compile(r"\.(ts|mts|cts|js|mjs|cjs)$")
+_NITRO_SKIP = re.compile(r"\.(test|spec)\.[cm]?[jt]s$|\.d\.ts$")
+_PROXY_CALL = re.compile(r"\b(proxyRequest|sendProxy)\s*\(")
+
+
+def nitro_route(rel: str, prefix: str = "") -> tuple[str, str] | None:
+    """Path of a file inside server/api or server/routes -> (METHOD, uri), or None for a non-route file.
+
+    `plants/[id].get.ts` with prefix `/api` -> (GET, /api/plants/{id}); no method suffix -> ANY; `index` is the
+    directory; `[...slug]` -> {slug*}, `[...]` -> {_*}; `(group)` directories are dropped; `.dev` / `.prod` /
+    `.prerender` env suffixes are ignored."""
+    if not _NITRO_EXT.search(rel) or _NITRO_SKIP.search(rel):
+        return None
+    parts = [p for p in _NITRO_EXT.sub("", rel).split("/") if p]
+    if not parts:
+        return None
+    last = parts[-1]
+    last = re.sub(r"\.(dev|prod|prerender)$", "", last)
+    method = "ANY"
+    m = re.match(r"^(.+)\.(%s)$" % "|".join(NITRO_METHODS), last)
+    if m:
+        last, method = m.group(1), m.group(2).upper()
+    parts[-1] = last
+    segs = []
+    for i, s in enumerate(parts):
+        if re.fullmatch(r"\(.*\)", s):
+            continue
+        if s == "index" and i == len(parts) - 1:
+            continue
+        if s == "[...]":
+            segs.append("{_*}")
+            continue
+        mm = re.fullmatch(r"\[\.\.\.(\w+)\]", s)
+        if mm:
+            segs.append("{%s*}" % mm.group(1))
+            continue
+        segs.append(re.sub(r"\[(\w+)\]", r"{\1}", s))
+    return method, "/" + "/".join(s.strip("/") for s in [prefix.strip("/")] + segs if s.strip("/"))
+
+
+def server_dirs(root: Path, src_dir: str) -> list[str]:
+    """Nitro server dirs of a Nuxt project: the root server/ (Nuxt 4 serverDir) and <srcDir>/server (Nuxt 3)."""
+    cands = ["server"] + ([] if src_dir in ("", ".") else [f"{src_dir.strip('/')}/server"])
+    return [d for d in dict.fromkeys(cands) if (root / d).is_dir()]
+
+
+# ------------------------------------------------------------ i18n locale files (#182)
+# a top-level key shaped like a locale code: en, pt-BR, zh_Hant, es-419
+LOCALE_RE = re.compile(r"^[a-z]{2,3}(?:[-_](?:[A-Z]{2}|[A-Z][a-z]{3}|\d{3}))*$")
+_KNOWN_LOCALES = {"en", "ar", "ku", "fr", "de"}
+LOCALE_EXTS = (".json", ".yaml", ".yml")
+
+
+def json_key_lines(text: str) -> dict[str, int]:
+    """Dotted key path -> line of the key, for the objects of a JSON document (keys inside arrays are skipped,
+    as flatten() treats arrays as values)."""
+    out: dict[str, int] = {}
+    stack: list[list] = []   # [type, current key, expecting a key]
+    pending = None
+    i, n, line = 0, len(text), 1
+    while i < n:
+        c = text[i]
+        if c == "\n":
+            line += 1
+        elif c == '"':
+            j = i + 1
+            while j < n and text[j] != '"':
+                j += 2 if text[j] == "\\" else 1
+            raw = text[i:j + 1]
+            if stack and stack[-1][0] == "obj" and stack[-1][2]:
+                try:
+                    pending = (json.loads(raw), line)
+                except ValueError:
+                    pending = (raw.strip('"'), line)
+            line += raw.count("\n")
+            i = j + 1
+            continue
+        elif c == ":" and pending is not None and stack and stack[-1][0] == "obj":
+            stack[-1][1], stack[-1][2] = pending[0], False
+            if all(f[0] == "obj" for f in stack):
+                out.setdefault(".".join(str(f[1]) for f in stack), pending[1])
+            pending = None
+        elif c == "{":
+            stack.append(["obj", None, True])
+        elif c == "[":
+            stack.append(["arr", None, False])
+        elif c in "}]":
+            if stack:
+                stack.pop()
+        elif c == "," and stack and stack[-1][0] == "obj":
+            stack[-1][2] = True
+        i += 1
+    return out
+
+
+def yaml_key_lines(text: str) -> dict[str, int]:
+    import yaml
+    out: dict[str, int] = {}
+
+    def walk(node, prefix):
+        if isinstance(node, yaml.MappingNode):
+            for k, v in node.value:
+                key = f"{prefix}.{k.value}" if prefix else str(k.value)
+                out.setdefault(key, k.start_mark.line + 1)
+                walk(v, key)
+    try:
+        walk(yaml.compose(text), "")
+    except Exception:
+        pass
+    return out
+
+
+def load_locale_file(f: Path) -> tuple[object, dict[str, int]]:
+    """(data, key path -> line) of a JSON / YAML locale file; (None, {}) when it does not parse."""
+    try:
+        text = f.read_text(errors="replace")
+        if f.suffix == ".json":
+            return json.loads(text), json_key_lines(text)
+        import yaml
+        return yaml.safe_load(text), yaml_key_lines(text)
+    except Exception:
+        return None, {}
+
+
+def nuxt_i18n_config(root: Path) -> dict:
+    """Literal slice of nuxt.config `i18n`: defaultLocale, langDir, locale codes and their files."""
+    cfg = _config_path(root)
+    if not cfg:
+        return {}
+    try:
+        obj = _find_config_object(cfg.read_text(errors="replace"))
+    except Exception:
+        return {}
+    i18n = obj.get("i18n") if isinstance(obj.get("i18n"), dict) else {}
+    codes, files = [], {}
+    for loc in i18n.get("locales") or [] if isinstance(i18n.get("locales"), list) else []:
+        if isinstance(loc, str):
+            codes.append(loc)
+        elif isinstance(loc, dict) and isinstance(loc.get("code"), str):
+            codes.append(loc["code"])
+            fs = [loc["file"]] if isinstance(loc.get("file"), str) else []
+            fs += [x for x in loc.get("files") or [] if isinstance(x, str)] if isinstance(loc.get("files"), list) else []
+            fs += [x["path"] for x in loc.get("files") or [] if isinstance(x, dict) and isinstance(x.get("path"), str)] \
+                if isinstance(loc.get("files"), list) else []
+            for x in fs:
+                files[x.lstrip("./")] = loc["code"]
+    return {"default_locale": i18n.get("defaultLocale") if isinstance(i18n.get("defaultLocale"), str) else None,
+            "lang_dir": i18n.get("langDir") if isinstance(i18n.get("langDir"), str) else None,
+            "locales": codes, "files": files}
+
+
+def locale_dirs(root: Path, src_dir: str, lang_dir: str | None) -> list[str]:
+    dirs = ["i18n/locales", f"{src_dir}/locales" if src_dir not in ("", ".") else "locales", "app/locales", "locales"]
+    if lang_dir:
+        ld = lang_dir.strip().lstrip("./").rstrip("/")
+        dirs = [f"i18n/{ld}", (f"{src_dir}/{ld}" if src_dir not in ("", ".") else ld), ld] + dirs
+    return [d for d in dict.fromkeys(dirs) if d and (root / d).is_dir()]
+
+
+def _sfc_key_lines(text: str, keys: list[str]) -> dict[str, int]:
+    """Line of each key's last segment inside the SFC's <i18n> block (the block's line when it is not found)."""
+    m = re.search(r"<i18n\b[^>]*>", text)
+    if not m:
+        return {}
+    base = text.count("\n", 0, m.start()) + 1
+    body = text[m.end():]
+    end = body.find("</i18n>")
+    body = body if end < 0 else body[:end]
+    out = {}
+    for k in keys:
+        last = k.split(".")[-1]
+        km = re.search(r"[\"']?%s[\"']?\s*:" % re.escape(last), body)
+        out[k] = base + (body.count("\n", 0, km.start()) if km else 0)
+    return out
+
+
+def i18n_definitions(root: Path, src_dir: str, sfc_i18n: dict) -> tuple[dict, list[str], str | None]:
+    """key -> [{locale, file, line}], the project's locales, and the default locale (nuxt.config defaultLocale, else
+    the first locale found). A file keyed by locale codes ({"en": {...}, "pt-BR": {...}}) defines every locale."""
+    cfg = nuxt_i18n_config(root)
+    configured = set(cfg.get("locales") or [])
+    defs: dict[str, list[dict]] = {}
+    seen_locales: list[str] = []
+
+    def add(key, locale, rel, line):
+        defs.setdefault(key, []).append({"locale": locale, "file": rel, "line": line or 1})
+        if locale and locale not in seen_locales:
+            seen_locales.append(locale)
+
+    for d in locale_dirs(root, src_dir, cfg.get("lang_dir")):
+        for f in sorted(p for p in (root / d).glob("*") if p.suffix in LOCALE_EXTS and p.is_file()):
+            data, lines = load_locale_file(f)
+            if not isinstance(data, dict) or not data:
+                continue
+            rel = f.relative_to(root).as_posix()
+            top = list(data)
+            stem_locale = f.stem if (LOCALE_RE.match(f.stem) or f.stem in configured) else None
+            keyed = all(isinstance(data[k], dict) and isinstance(k, str) for k in top) and (
+                set(top) <= (configured or _KNOWN_LOCALES) or set(top) <= _KNOWN_LOCALES
+                or (stem_locale is None and all(LOCALE_RE.match(k) for k in top)))
+            if keyed:
+                for loc in top:
+                    for k in flatten(data[loc]):
+                        add(k, loc, rel, lines.get(f"{loc}.{k}"))
+            else:
+                loc = cfg.get("files", {}).get(f.name) or cfg.get("files", {}).get(rel) or stem_locale
+                for k in flatten(data):
+                    add(k, loc, rel, lines.get(k))
+    for f, keys in sfc_i18n.items():
+        try:
+            text = (root / f).read_text(errors="replace")
+        except OSError:
+            text = ""
+        kl = _sfc_key_lines(text, keys)
+        for k in keys:
+            add(k, None, f, kl.get(k, 1))
+    default = cfg.get("default_locale") or (seen_locales[0] if seen_locales else None)
+    locales = list(dict.fromkeys([*configured, *seen_locales]))
+    return defs, locales, default
+
+
 def flatten(d, prefix=""):
     if isinstance(d, dict):
         for k, v in d.items():
@@ -928,27 +1153,119 @@ class NuxtPlugin(FrameworkPlugin):
             if lay in layouts:
                 builder.add_edge(n.id, layouts[lay], "USES_LAYOUT", file=n.file, line=1,
                                  confidence="exact" if n.file in meta and meta[n.file].get("layout") else "resolved")
-        # i18n: keys used in code/templates, and where they are defined
-        defined = {}
-        for d in dict.fromkeys(("i18n/locales", f"{self.src_dir}/locales", "app/locales", "locales")):
-            for f in sorted((project.root / d).glob("*.json")) if (project.root / d).exists() else []:
-                try:
-                    data = json.loads(f.read_text())
-                except Exception:
-                    continue
-                locs = {"en", "ar", "ku", "fr", "de"}
-                if isinstance(data, dict) and set(data) and set(data) <= locs:
-                    data = next(iter(data.values()))
-                for k in flatten(data):
-                    defined.setdefault(k, []).append(str(f.relative_to(project.root)))
-        for f, keys in (ctx.facts.get("sfc_i18n") or {}).items():
-            for k in keys:
-                defined.setdefault(k, []).append(f)
+        # i18n: keys used in code/templates, and where they are defined (#182)
+        defs, locales, default = i18n_definitions(project.root, self.src_dir, ctx.facts.get("sfc_i18n") or {})
+        used: dict[str, int] = {}
         for u in ctx.facts.get("i18n") or []:
-            nid = builder.add_node("i18n", u["key"], u["key"], lang="ts", attrs={"defined_in": defined.get(u["key"], [])})
+            used[u["key"]] = used.get(u["key"], 0) + 1
+        for u in ctx.facts.get("i18n") or []:
+            key = u["key"]
+            ds = defs.get(key) or []
+            home = next((d for d in ds if default and d["locale"] == default), ds[0] if ds else None)
+            attrs = {"defined_in": list(dict.fromkeys(d["file"] for d in ds)), "definitions": ds, "uses": used[key]}
+            have = {d["locale"] for d in ds if d["locale"]}
+            if default and default in have:
+                missing = sorted(set(locales) - have)
+                if missing:
+                    attrs["missing_locales"] = missing
+            nid = builder.add_node("i18n", key, key, lang="ts", file=home["file"] if home else None,
+                                   line=home["line"] if home else None, attrs=attrs)
             builder.add_edge(u["src"], nid, "USES_I18N", file=u["file"], line=u["line"],
-                             confidence="exact" if u["key"] in defined else "heuristic")
+                             confidence="exact" if key in defs else "heuristic")
+        defined = defs
+        st["i18n_locales"] = sorted(locales)
+        st["i18n_default_locale"] = default
         st["i18n_keys_used"] = len({u["key"] for u in ctx.facts.get("i18n") or []})
+        st["nitro"] = self._nitro(project, builder)
         st["i18n_keys_defined"] = len(defined)
         st["i18n_used_but_undefined"] = len({u["key"] for u in ctx.facts.get("i18n") or []} - set(defined))
         return st
+
+    # ------------------------------------------------------------ Nitro server routes (#216)
+    def _nitro(self, project: Project, b: GraphBuilder) -> dict:
+        from ..tsweb.common import add_route
+        st = {"routes": 0, "middleware": 0, "plugins": 0, "proxy_routes": 0, "linked_calls": 0}
+        dirs = server_dirs(project.root, self.src_dir)
+        if not dirs:
+            return st
+        files = sorted({n.file for n in b.nodes.values() if n.lang == "ts" and n.kind == "module" and n.file})
+
+        def handler(f: str) -> tuple[str | None, str]:
+            for nid in (f"function:{f}#default", f"function:{f}#handler"):
+                if b.has(nid):
+                    return nid, "exact"
+            return (f"module:{f}", "resolved") if b.has(f"module:{f}") else (None, "heuristic")
+
+        def label(f: str, kind: str):
+            for nid in (f"module:{f}", handler(f)[0]):
+                if nid and b.has(nid):
+                    b.nodes[nid].attrs["nitro"] = kind
+
+        middleware, routes = [], []
+        for d in dirs:
+            for f in files:
+                if not f.startswith(d + "/"):
+                    continue
+                rest = f[len(d) + 1:]
+                top, _, inner = rest.partition("/")
+                if top == "middleware" and inner and nitro_route(inner) is not None:
+                    h, _c = handler(f)
+                    if h:
+                        label(f, "middleware")
+                        middleware.append((h, f"nitro:{_NITRO_EXT.sub('', inner)}", "resolved"))
+                        st["middleware"] += 1
+                elif top == "plugins" and inner and nitro_route(inner) is not None:
+                    h, _c = handler(f)
+                    if h:
+                        label(f, "plugin")
+                        b.nodes[h].entry_kind = b.nodes[h].entry_kind or "main"
+                        st["plugins"] += 1
+                elif top in ("api", "routes") and inner:
+                    r = nitro_route(inner, "/api" if top == "api" else "")
+                    if r:
+                        routes.append((f, top, r))
+        for f, top, (method, uri) in routes:
+            h, conf = handler(f)
+            line = (b.nodes[h].line or 1) if h else 1
+            attrs = {"file_route": True, "nitro_dir": top, "method_from": "file suffix" if method != "ANY" else "any"}
+            try:
+                src = (project.root / f).read_text(errors="replace")
+            except OSError:
+                src = ""
+            if _PROXY_CALL.search(src):
+                attrs["proxy"] = True
+                st["proxy_routes"] += 1
+            if not h or h.startswith("module:"):
+                attrs["handler_unresolved"] = True
+            add_route(b, method, uri, [h] if h else [], f, line, "nuxt", conf, attrs, middleware)
+            label(f, "route")
+            st["routes"] += 1
+        st["linked_calls"] = self._link_nitro(b)
+        return st
+
+    def _link_nitro(self, b: GraphBuilder) -> int:
+        """Same-origin client calls of this app (relative URLs: `$fetch('/api/x')`, `useFetch`) -> its Nitro routes.
+        Proxy routes (proxyRequest / sendProxy) forward elsewhere and are not link targets."""
+        from ...link import match_endpoint
+        routes = []
+        for n in b.nodes.values():
+            a = n.attrs
+            if n.kind == "route" and a.get("framework") == "nuxt" and a.get("uri") and not a.get("proxy"):
+                routes.append({"id": n.id, "uri": a["uri"], "method": a["method"], "uris": [("as-declared", a["uri"])],
+                               "file": n.file, "line": n.line})
+        if not routes:
+            return 0
+        rmap = {r["id"]: r for r in routes}
+        linked = 0
+        for n in list(b.nodes.values()):
+            a = n.attrs
+            if n.kind != "http" or n.lang != "ts" or a.get("origin_kind") != "same-origin":
+                continue
+            res = match_endpoint(a.get("method", "GET"), a.get("path", ""), routes, "api", None)
+            for m in res["matched"]:
+                r = rmap[m["route"]]
+                b.add_edge(n.id, m["route"], "MATCHES_ROUTE", file=r["file"], line=r["line"], confidence=m["confidence"],
+                           client_path=a.get("path"), uri_variant=m["uri_variant"], segments=m["segments"], in_repo=True)
+            if res["matched"]:
+                linked += 1
+        return linked

{cg_code_graph-0.23.1 → cg_code_graph-0.23.2}/cg_code_graph/plugins/ts/extractor/extract.mjs

@@ -63,7 +63,11 @@ const INDEX_TESTS = cfg.index_tests !== false
 const TEST_FILE_RE = /\.(test|spec|e2e-spec|e2e|cy)\.(t|j)sx?$/
 const TEST_DIR_RE = /(^|\/)(__tests__|e2e|tests?|cypress|playwright)\//
 const TEST_ROOTS = ['e2e', 'test', 'tests', 'cypress', 'playwright', 'src/test', 'src/tests', 'src/e2e']
-const isTestRel = r => TEST_FILE_RE.test(r) || /(^|\/)__tests__\//.test(r) || TEST_ROOTS.some(d => r.startsWith(d + '/'))
+// nested test trees (#156): a `playwright/` or `cypress/` directory below the top level (help/playwright/), and a nested
+// `e2e/` outside the source dirs, are test roots like the top-level ones (filled once the source dirs are known)
+const NESTED_TEST_NAMES = new Set(['playwright', 'cypress', 'e2e'])
+const nestedTestRoots = []
+const isTestRel = r => TEST_FILE_RE.test(r) || /(^|\/)__tests__\//.test(r) || TEST_ROOTS.some(d => r.startsWith(d + '/')) || nestedTestRoots.some(d => r.startsWith(d + '/'))
 
 // ---------- file kinds (from the framework plugin: [[prefix, kind], ...]) ----------
 function fileKind(r) {
@@ -270,9 +274,25 @@ function walkTests(d, all, forced = false) {
     else if (SRC_EXT.test(e.name) && (e.isFile() || (e.isSymbolicLink() && !skippedLinks.includes(rel(p)) && fileEntry(e, p))) && !e.name.endsWith('.d.ts') && (all || isTestRel(rel(p)))) testFiles.add(p)
   }
 }
+function findNestedTestRoots(d, depth) {
+  if (depth > 6) return
+  let ents = []
+  try { ents = fs.readdirSync(d, { withFileTypes: true }) } catch { return }
+  for (const e of ents) {
+    if (!e.isDirectory()) continue
+    const p = path.join(d, e.name), r = rel(p)
+    if (skipDir(e.name, r, TEST_SKIP_NAMES, false) || excludedRel(r + '/') || TEST_ROOTS.includes(r)) continue
+    if (depth > 0 && NESTED_TEST_NAMES.has(e.name) && (e.name !== 'e2e' || !srcDirs.some(s => p === s || p.startsWith(s + path.sep)))) {
+      nestedTestRoots.push(r)
+      continue
+    }
+    findNestedTestRoots(p, depth + 1)
+  }
+}
 if (INDEX_TESTS) {
+  findNestedTestRoots(ROOT, 0)
   for (const d of srcDirs) walkTests(d, false)
-  for (const d of TEST_ROOTS) { const p = path.resolve(ROOT, d); if (fs.existsSync(p) && fs.statSync(p).isDirectory()) walkTests(p, true) }
+  for (const d of [...TEST_ROOTS, ...nestedTestRoots]) { const p = path.resolve(ROOT, d); if (fs.existsSync(p) && fs.statSync(p).isDirectory()) walkTests(p, true) }
 }
 // scripts the tests run in a subprocess (`spawnSync('node', [path.join(__dirname, '..', 'tools', 'gen.js')])`,
 // `execSync('node tools/gen.js')`) outside every source dir are source files too, so the subprocess link
@@ -3728,6 +3748,6 @@ fs.writeFileSync(cfg.out, JSON.stringify({ nodes, edges, api_calls: apiCalls, i1
   // for `cg coverage` (#106): the files analysed, and the roots they come from (source dirs, source files, test trees);
   // a discovered file outside every root was never read, so it is not indexed rather than exact
   seen_files: [...new Set(sourceFiles.map(sf => rel(realFile(sf))))].sort(),
-  roots: [...srcDirs.map(d => rel(d) + '/'), ...[...srcFiles].map(rel), ...TEST_ROOTS.map(d => d + '/')].filter(r => r && r !== '/' && !r.startsWith('..')),
+  roots: [...srcDirs.map(d => rel(d) + '/'), ...[...srcFiles].map(rel), ...TEST_ROOTS.map(d => d + '/'), ...nestedTestRoots.map(d => d + '/')].filter(r => r && r !== '/' && !r.startsWith('..')),
   stats }))
 console.log(JSON.stringify(stats))

{cg_code_graph-0.23.1 → cg_code_graph-0.23.2}/cg_code_graph/query.py

@@ -44,6 +44,14 @@ def resolve_targets(st: GraphStore, spec: str) -> list[str]:
 
 
 
+def _search_hint(spec: str, ambiguous: bool = False) -> str:
+    """One line pointing at `cg search` (the MCP `search` tool) for a snippet spec that matched several nodes or none (#156)."""
+    q = spec if re.fullmatch(r"[\w.:#/$-]+", spec or "") else repr(spec)
+    if ambiguous:
+        return f"run `cg search {q}` (MCP: search) to see the matches with file:line, then snippet one id or FQN"
+    return f"try `cg search {q}` (MCP: search) with part of the name, then snippet a listed id or FQN"
+
+
 def snippet(st: GraphStore, spec: str, context: int = 0, max_lines: int = 200) -> dict:
     """Source of one symbol, read from disk via the node file / line / end_line. Returns a dict
     whose "status" is one of: ok (id, kind, file, start, end, shown_start, shown_end,
@@ -52,14 +60,15 @@ def snippet(st: GraphStore, spec: str, context: int = 0, max_lines: int = 200) -
     disk, with the paths tried). context adds lines around the span; max_lines caps the body."""
     ids = list(dict.fromkeys(resolve_targets(st, spec)))
     if not ids:
-        return {"status": "none", "spec": spec}
+        return {"status": "none", "spec": spec, "hint": _search_hint(spec)}
     if len(ids) > 1:
         cands = []
         for nid in ids[:20]:
             n = st.node(nid)
             cands.append({"id": nid, "kind": n["kind"] if n else "?",
                           "file": n["file"] if n else None, "line": n["line"] if n else None})
-        return {"status": "ambiguous", "spec": spec, "count": len(ids), "candidates": cands}
+        return {"status": "ambiguous", "spec": spec, "count": len(ids), "candidates": cands,
+                "hint": _search_hint(spec, ambiguous=True)}
     nid = ids[0]
     n = st.node(nid)
     if not n or not n["file"] or not n["line"]:
@@ -95,7 +104,7 @@ def render_snippet(res: dict) -> str:
     error line for a non-ok status."""
     status = res.get("status")
     if status == "none":
-        return f"no node matches {res['spec']!r}; try `search` with part of the name"
+        return f"no node matches {res['spec']!r}; {res.get('hint') or _search_hint(res['spec'])}"
     if status == "no_source":
         return f"{res['id']}: no source location recorded (nothing to show)"
     if status == "missing":
@@ -106,6 +115,7 @@ def render_snippet(res: dict) -> str:
         for c in res["candidates"]:
             loc = f"{c['file']}:{c['line']}" if c.get("file") else "(no source location)"
             out.append(f"  {c['id']}  [{c['kind']}]  {loc}")
+        out.append(res.get("hint") or _search_hint(res["spec"], ambiguous=True))
         return "\n".join(out)
     lines = res["lines"]
     out = [f"{res['file']}:{res['start']}-{res['end']}"]
@@ -1301,6 +1311,13 @@ def with_generated(row: dict) -> dict:
     """A node row without its raw attrs, plus `generated` (the reason) for a node from a generated / copied / vendored
     file (indexed with --include-generated)."""
     raw = row.pop("attrs", None)
+    if raw and row.get("kind") == "i18n":
+        try:
+            a = json.loads(raw) or {}
+        except ValueError:
+            a = {}
+        row["i18n"] = {"locales": len({d.get("locale") or d.get("file") for d in a.get("definitions") or []}),
+                       "uses": a.get("uses") or 0, "missing_locales": a.get("missing_locales") or []}
     if raw and ('"platforms"' in raw or '"available"' in raw):
         from .platforms import node_platforms
         row.update(node_platforms(raw))
@@ -1592,10 +1609,12 @@ def _impact(st: GraphStore, spec: str, min_conf: str, platform: str | None) -> d
         built = [t for t in targets if t not in set(not_built)]
         targets = built
     kinds = CALL_LIKE + DATA_USE if any(t.startswith(DATA_TARGET) for t in targets) else CALL_LIKE
+    if any(t.startswith("i18n:") for t in targets):
+        kinds = kinds + ["USES_I18N"]   # the components / pages showing a translation key are its callers (#182)
     si = _has_class_target(targets)
     rel = override_relations(st, targets, min_conf)
     below = override_seeds(st, spec, targets, min_conf)
-    cols = _table_columns(st, targets) if kinds is not CALL_LIKE else []
+    cols = _table_columns(st, targets) if any(t.startswith(DATA_TARGET) for t in targets) else []
     seeds = targets + cols + below
     depth = reverse_closure(st, seeds, kinds=kinds, min_conf=min_conf, seed_inst=si, platform=platform)
     own = reverse_closure(st, targets + cols, kinds=kinds, min_conf=min_conf, seed_inst=si, platform=platform) if below else depth
@@ -2517,6 +2536,18 @@ def search(st: GraphStore, name: str, kind: str | None = None, limit: int = 20,
     return out
 
 
+def _i18n_label(r: dict) -> str:
+    """`  (2 locales, 1 use)` for an i18n key row of search (#182)."""
+    a = r.get("i18n")
+    if not a:
+        return ""
+    locs, uses = a.get("locales") or 0, a.get("uses") or 0
+    out = f"  ({locs} locale{'s' if locs != 1 else ''}, {uses} use{'s' if uses != 1 else ''})"
+    if a.get("missing_locales"):
+        out += f"  missing: {', '.join(a['missing_locales'])}"
+    return out
+
+
 def render_search(res: dict, limit_routes: int = 8) -> str:
     out = []
     if res.get("platform"):
@@ -2526,7 +2557,7 @@ def render_search(res: dict, limit_routes: int = 8) -> str:
             out.append(f"{res['platform']['matches_not_built']} matching symbols are not built for {res['platform']['platform']} "
                        f"(search without platform lists them)")
     for r in res["nodes"]:
-        out.append(f"{r['kind']:10} {r['id']}  {r['file'] or '?'}:{r['line']}{platform_label(r)}")
+        out.append(f"{r['kind']:10} {r['id']}  {r['file'] or '?'}:{r['line']}{platform_label(r)}{_i18n_label(r)}")
     if res["guards"]:
         if out:
             out.append("")