cg-code-graph 0.10.1__py3-none-any.whl

codegraph/plugins/nextjs/plugin.py

@@ -0,0 +1,336 @@
+"""Next.js framework layer (on the TypeScript plugin).
+
+  app router   app/**/page.* -> page node (route in Next notation, e.g. /books/[id]; entry ui_page) RENDERS the default
+               export; layout/template/error/loading/not-found/default -> layout node (ui_global), pages USES_LAYOUT every
+               enclosing layout; route groups (x), parallel slots @x and private _folders are dropped, intercepting
+               routes (.)x (..)x (...)x are resolved to the URL they intercept (best effort)
+               app/**/route.* -> one route per exported HTTP verb (GET/POST/...; `export const GET = withAuth(fn)` and
+               `export { h as GET }` resolve to the wrapped function); dynamic segments [id] -> {id}, [...slug] ->
+               {slug*}, [[...slug]] -> {slug*?}
+  pages router pages/**/*.tsx -> page (ui_page; getServerSideProps/getStaticProps CALLS), _app/_document -> ui_global,
+               pages/api/** -> route per `req.method === 'X'` / switch case, else ANY
+  server actions  'use server' modules (exported functions) and inline 'use server' functions -> route
+               `ACTION <file>#<fn>` (entry http_route, method POST), clients reach them through ordinary CALLS
+  middleware   middleware.ts / proxy.ts: USES_MIDDLEWARE from every route/page its `config.matcher` covers (regex matchers
+               and no matcher: all, heuristic)
+  next.config  static basePath (prefixed to every route/page) and literal rewrites (recorded; internal destinations are
+               added as uri variants of the destination route)
+  links        fetch/axios/ky/SWR calls in the same repo -> route handlers (MATCHES_ROUTE, see tsweb.common.link_in_repo);
+               env keys incl. NEXT_PUBLIC_ (tsweb.data)
+"""
+from __future__ import annotations
+
+import re
+from pathlib import PurePosixPath
+
+from ...core.plugin import FrameworkPlugin, GraphBuilder, Project
+from ..tsweb.common import (HTTP_VERBS, TEST_SKIP_RE, add_route, express_path, finish, fw_facts, has_server_framework,
+                            join_path, merge_extractor_cfg, module_of, next_segment, obj, ref_nodes, register, sval, svals)
+
+EXT = r"\.(tsx|ts|jsx|js|mdx)$"
+SPECIAL = {"layout", "template", "error", "loading", "not-found", "default", "global-error", "forbidden", "unauthorized"}
+CONFIG_FILES = ("next.config.js", "next.config.mjs", "next.config.ts", "next.config.cjs")
+
+
+class NextPlugin(FrameworkPlugin):
+    name, language = "nextjs", "typescript"
+
+    def detect(self, project: Project) -> bool:
+        return has_server_framework(project, "next") or any(project.exists(f) for f in CONFIG_FILES)
+
+    def register_hooks(self, ctx) -> None:
+        root = ctx.project.root
+        merge_extractor_cfg(ctx.extractor_cfg, src_dirs=["."], skip_re=TEST_SKIP_RE + r"|(^|/)(public|scripts)(/|$)",
+                            extra_files=[f for f in CONFIG_FILES if (root / f).exists()] +
+                            [f for f in ("middleware.ts", "middleware.js", "src/middleware.ts", "src/middleware.js", "proxy.ts", "src/proxy.ts") if (root / f).exists()],
+                            walk_src=not (root / "tsconfig.json").exists())
+        register(ctx, self.name)
+
+    # ------------------------------------------------------------
+    def contribute(self, project: Project, b: GraphBuilder, ctx) -> dict:
+        st = {"pages": 0, "layouts": 0, "route_handlers": 0, "api_routes": 0, "server_actions": 0, "middleware": None,
+              "base_path": None, "rewrites": 0}
+        F = fw_facts(ctx)
+        if not F:
+            return {**st, "status": "no facts"}
+        self.b, self.F = b, F
+        mods = F.get("modules") or {}
+        self.mods = mods
+        root = project.root
+        app_dirs = [d for d in ("app", "src/app") if (root / d).is_dir()]
+        page_dirs = [d for d in ("pages", "src/pages") if (root / d).is_dir()]
+        base_path, rewrites = self._config(mods)
+        st["base_path"], st["rewrites"] = base_path, len(rewrites)
+        self.base = base_path or ""
+        files = sorted({n.file for n in b.nodes.values() if n.lang == "ts" and n.kind == "module" and n.file})
+        self.routes, self.pages = [], []
+        layouts_by_dir = {}
+        for f in files:
+            for ad in app_dirs:
+                if not f.startswith(ad + "/") or not re.search(EXT, f):
+                    continue
+                stem = re.sub(EXT, "", PurePosixPath(f).name)
+                rel_dir = str(PurePosixPath(f).parent)[len(ad):].strip("/")
+                url = self._app_url(rel_dir)
+                if url is None:
+                    continue
+                if stem == "page":
+                    self._page(f, url, "app", st)
+                elif stem == "route":
+                    self._route_handlers(f, url, st)
+                elif stem in SPECIAL:
+                    lid = self._layout(f, stem, st)
+                    layouts_by_dir.setdefault(str(PurePosixPath(f).parent), []).append(lid)
+            for pd in page_dirs:
+                if not f.startswith(pd + "/") or not re.search(EXT, f):
+                    continue
+                rel = re.sub(EXT, "", f[len(pd) + 1:])
+                parts = rel.split("/")
+                if parts[0] == "api":
+                    url = self._pages_url(parts)
+                    if url is not None:
+                        self._api_route(f, url, st)
+                elif parts[-1] in ("_app", "_document", "_error") and len(parts) == 1:
+                    lid = self._layout(f, parts[-1], st)
+                    layouts_by_dir.setdefault(pd, []).append(lid)
+                elif not any(p.startswith("_") for p in parts):
+                    url = self._pages_url(parts)
+                    if url is not None:
+                        self._page(f, url, "pages", st)
+        # pages use every enclosing layout (app router) / _app (pages router)
+        for pid, f in self.pages:
+            d = PurePosixPath(f).parent
+            while True:
+                for lid in layouts_by_dir.get(str(d), []):
+                    if lid != pid:
+                        b.add_edge(pid, lid, "USES_LAYOUT", file=f, line=1, confidence="exact")
+                if str(d) in app_dirs + page_dirs or str(d) in (".", ""):
+                    break
+                d = d.parent
+        self._server_actions(st)
+        self._middleware(st)
+        for src, dst in rewrites:
+            for r in self.routes:
+                n = b.nodes[r]
+                if n.attrs.get("uri") == express_path(self.base + dst) and not re.search(r"^https?:", dst):
+                    n.attrs.setdefault("uri_variants", []).append(express_path(self.base + src))
+                    n.attrs.setdefault("rewrites", []).append({"source": src, "destination": dst})
+        st.update(finish(project, b, ctx, self.name))
+        return st
+
+    # ------------------------------------------------------------ paths
+    def _app_url(self, rel_dir: str) -> str | None:
+        segs = []
+        for s in [x for x in rel_dir.split("/") if x]:
+            m = re.match(r"^(\((?:\.{1,3}|\.\.\)\(\.\.)\))(.*)$", s)   # intercepting route
+            if m:
+                marker, rest = m.group(1), m.group(2)
+                if marker == "(.)":
+                    pass
+                elif marker == "(...)":
+                    segs = []
+                else:
+                    ups = marker.count("..")
+                    segs = segs[:max(0, len(segs) - ups)]
+                s = rest
+            ns = next_segment(s)
+            if ns is None:
+                return None
+            if ns:
+                segs.append(ns)
+        return "/" + "/".join(segs)
+
+    def _pages_url(self, parts: list[str]) -> str | None:
+        segs = []
+        for i, p in enumerate(parts):
+            if p == "index" and i == len(parts) - 1:
+                continue
+            ns = next_segment(p)
+            if ns is None:
+                return None
+            if ns:
+                segs.append(ns)
+        return "/" + "/".join(segs)
+
+    @staticmethod
+    def _page_name(url: str) -> str:
+        return re.sub(r"\{(\w+)\*\?\}", r"[[...\1]]", re.sub(r"\{(\w+)\*\}", r"[...\1]", re.sub(r"\{(\w+)\}", r"[\1]", url)))
+
+    def _exports(self, f) -> dict:
+        return {e["name"]: e for e in (self.mods.get(f) or {}).get("exports") or []}
+
+    def _targets(self, ex: dict | None) -> tuple[list[str], str]:
+        if not ex:
+            return [], "exact"
+        if ex.get("node") and self.b.has(ex["node"]):
+            return [ex["node"]], "exact"
+        nodes = [n for n in ref_nodes(ex.get("desc")) if self.b.has(n)]
+        return nodes, "resolved"
+
+    # ------------------------------------------------------------ nodes
+    def _page(self, f, url, router, st):
+        b = self.b
+        name = self._page_name(join_path(self.base, url) if self.base else url)
+        pid = b.add_node("page", f, name=name, fqn=name, file=f, line=1, module=module_of(f), lang="ts",
+                         attrs={"route": name, "uri": express_path(join_path(self.base, url)), "framework": "nextjs", "router": router})
+        b.nodes[pid].entry_kind = "ui_page"
+        ex = self._exports(f)
+        tg, conf = self._targets(ex.get("default"))
+        for t in tg:
+            b.add_edge(pid, t, "RENDERS", file=f, line=b.nodes[t].line or 1, confidence=conf)
+        b.add_edge(pid, f"module:{f}", "RENDERS", file=f, line=1, confidence="exact") if not tg and b.has(f"module:{f}") else None
+        for data_fn in ("getServerSideProps", "getStaticProps", "getStaticPaths", "generateMetadata", "generateStaticParams", "getInitialProps"):
+            tg2, c2 = self._targets(ex.get(data_fn))
+            for t in tg2:
+                b.add_edge(pid, t, "CALLS", file=f, line=b.nodes[t].line or 1, confidence=c2, data_fetching=data_fn)
+        self.pages.append((pid, f))
+        st["pages"] += 1
+
+    def _layout(self, f, stem, st):
+        b = self.b
+        lid = b.add_node("layout", f, name=f, file=f, line=1, module=module_of(f), lang="ts", attrs={"framework": "nextjs", "next_kind": stem})
+        b.nodes[lid].entry_kind = "ui_global"
+        tg, conf = self._targets(self._exports(f).get("default"))
+        for t in tg:
+            b.add_edge(lid, t, "RENDERS", file=f, line=b.nodes[t].line or 1, confidence=conf)
+        st["layouts"] += 1
+        return lid
+
+    def _route_handlers(self, f, url, st):
+        ex = self._exports(f)
+        uri = express_path(join_path(self.base, url))
+        for verb in HTTP_VERBS:
+            if verb not in ex:
+                continue
+            tg, conf = self._targets(ex[verb])
+            e = ex[verb]
+            attrs = {"file_route": True}
+            d = e.get("desc") or {}
+            if "call" in d:
+                attrs["wrapped_by"] = d["call"]
+            if not tg:
+                attrs["handler_unresolved"] = True
+            mw = [(n, d["call"], "resolved") for n in [d.get("node")] if n and "call" in d and self.b.has(n)]
+            rid = add_route(self.b, verb, uri, tg, f, e.get("line") or 1, "nextjs", conf, attrs, mw)
+            self.routes.append(rid)
+            st["route_handlers"] += 1
+
+    def _api_route(self, f, url, st):
+        ex = self._exports(f)
+        tg, conf = self._targets(ex.get("default"))
+        checks = (self.mods.get(f) or {}).get("method_checks") or []
+        methods = sorted({c["method"] for c in checks}) or ["ANY"]
+        uri = express_path(join_path(self.base, "/api", url[len("/api"):] if url.startswith("/api") else url))
+        d = (ex.get("default") or {}).get("desc") or {}
+        mw = [(n, d["call"], "resolved") for n in [d.get("node")] if n and "call" in d and self.b.has(n)]
+        for m in methods:
+            rid = add_route(self.b, m, uri, tg, f, (ex.get("default") or {}).get("line") or 1, "nextjs", conf,
+                            {"pages_api": True, "method_from": "req.method check" if checks else "any"}, mw)
+            self.routes.append(rid)
+            st["api_routes"] += 1
+
+    def _server_actions(self, st):
+        b = self.b
+        seen = set()
+        for f, m in self.mods.items():
+            fns = list(m.get("server_fns") or [])
+            if "use server" in (m.get("directives") or []):
+                fns += [e["node"] for e in m.get("exports") or [] if e.get("node") and e["node"].startswith("function:")]
+            for fn in fns:
+                if fn in seen or not b.has(fn):
+                    continue
+                seen.add(fn)
+                n = b.nodes[fn]
+                key = f"ACTION {fn.split(':', 1)[1]}"
+                rid = b.add_node("route", key, name=key, file=n.file, line=n.line, module=module_of(n.file), lang="ts", entry_kind="http_route",
+                                 attrs={"method": "POST", "server_action": True, "framework": "nextjs", "handler": n.name})
+                b.add_edge(rid, fn, "ROUTES_TO", file=n.file, line=n.line, confidence="exact")
+                st["server_actions"] += 1
+
+    def _middleware(self, st):
+        b = self.b
+        for f in ("middleware.ts", "middleware.js", "src/middleware.ts", "src/middleware.js", "proxy.ts", "proxy.js", "src/proxy.ts"):
+            m = self.mods.get(f)
+            if not m:
+                continue
+            ex = {e["name"]: e for e in m.get("exports") or []}
+            fn = (ex.get("middleware") or ex.get("proxy") or ex.get("default") or {}).get("node")
+            if not fn or not b.has(fn):
+                tg = ref_nodes((ex.get("default") or {}).get("desc"))
+                fn = tg[0] if tg else None
+            if not fn:
+                continue
+            cfg = obj((ex.get("config") or {}).get("desc"))
+            matchers = svals(cfg.get("matcher")) or [sval(obj(x).get("source")) for x in (cfg.get("matcher") or {}).get("arr") or [] if sval(obj(x).get("source"))]
+            regex = [p for p in matchers if re.search(r"[()|\\^$]", p)]
+            pats = [p for p in matchers if p not in regex]
+            st["middleware"] = {"file": f, "matchers": matchers}
+            targets = [(r, b.nodes[r].attrs.get("uri")) for r in self.routes] + [(p, b.nodes[p].attrs.get("uri")) for p, _ in self.pages]
+            for nid, uri in targets:
+                if not uri:
+                    continue
+                if not matchers or regex:
+                    hit, conf = (not regex or self._regex_hit(regex, uri)), "heuristic"
+                else:
+                    hit, conf = any(self._matcher_hit(p, uri) for p in pats), "resolved"
+                if hit:
+                    b.add_edge(nid, fn, "USES_MIDDLEWARE", file=f, line=b.nodes[fn].line or 1, confidence=conf, name="middleware")
+
+    def _matcher_hit(self, pat: str, uri: str) -> bool:
+        p = express_path(pat)
+        ps, us = [s for s in p.split("/") if s], [s for s in uri.split("/") if s]
+        for i, s in enumerate(ps):
+            if re.fullmatch(r"\{\w+\*\??\}", s):
+                return len(us) >= i + (0 if s.endswith("?}") else 1)
+            if i >= len(us):
+                return bool(re.fullmatch(r"\{\w+\?\}", s))
+            if s.startswith("{") or us[i].startswith("{") or s == us[i]:
+                continue
+            return False
+        return len(us) == len(ps)
+
+    @staticmethod
+    def _regex_hit(regex: list[str], uri: str) -> bool:
+        probe = re.sub(r"\{(\w+)\*?\??\}", r"x", uri)
+        for r in regex:
+            try:
+                if re.fullmatch(r.replace("/:path*", "(/.*)?"), probe) or re.match(r, probe):
+                    return True
+            except re.error:
+                return True
+        return False
+
+    def _config(self, mods):
+        base, rewrites = None, []
+        for f in CONFIG_FILES:
+            m = mods.get(f)
+            if not m:
+                continue
+            ex = {e["name"]: e for e in m.get("exports") or []}
+            d = (ex.get("default") or ex.get("export=") or {}).get("desc") or {}
+            o = self._config_obj(d)
+            base = sval(o.get("basePath")) or None
+            rw = o.get("rewrites") or {}
+            for x in (rw.get("ret") or [rw.get("body")] if (rw.get("ret") or rw.get("body")) else []):
+                for it in (x or {}).get("arr") or []:
+                    s, t = sval(obj(it).get("source")), sval(obj(it).get("destination"))
+                    if s and t:
+                        rewrites.append((s, t))
+        return base, rewrites
+
+    def _config_obj(self, d, depth=0) -> dict:
+        if not isinstance(d, dict) or depth > 4:
+            return {}
+        if d.get("obj") is not None:
+            return d["obj"]
+        if d.get("key"):
+            inst = (self.F.get("instances") or {}).get(d["key"]) or {}
+            return self._config_obj(inst.get("init"), depth + 1)
+        if "call" in d:   # withPlugins(nextConfig) / withBundleAnalyzer({...})
+            for a in d.get("args") or []:
+                o = self._config_obj(a, depth + 1)
+                if o:
+                    return o
+        if d.get("body") or d.get("ret"):
+            return self._config_obj(d.get("body") or (d.get("ret") or [None])[0], depth + 1)
+        return {}

codegraph/plugins/nuxt/plugin.py

@@ -0,0 +1,308 @@
+"""Nuxt framework plugin (on the TypeScript plugin).
+
+register_hooks: finds the source dir (nuxt.config `srcDir`, else `app/` (Nuxt 4), `src/`, or the repo root
+  (Nuxt 3 default)) and points the TS extractor at Nuxt's generated types (.nuxt/tsconfig.app.json or
+  .nuxt/tsconfig.json, whose nuxt.d.ts pulls in .nuxt/types/imports.d.ts = auto-imported composables /
+  utils / stores) and the generated global-components map (.nuxt/types/components.d.ts), plus Nuxt
+  directory conventions (pages/, layouts/, components/, composables/, stores/, utils/, middleware/, plugins/).
+  A clean checkout without .nuxt (no `nuxi prepare` run) gets an equivalent generated on the fly in a temp
+  dir: path aliases (~, @, ~~, @@), auto-imports of composables/ utils/ stores/ exports, global components
+  with Nuxt's path-prefixed names. Vue / Nuxt built-ins resolve when node_modules is installed. The stats
+  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).
+"""
+from __future__ import annotations
+
+import atexit
+import json
+import re
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+from ... import presets
+from ...core.plugin import FrameworkPlugin, GraphBuilder, Project
+
+# dependency / VCS directories every walk skips (codegraph/presets/common.yaml skip_dirs)
+COMMON_SKIP = presets.skip_dirs("common")
+
+DIR_KINDS = [("pages/", "page"), ("layouts/", "layout"), ("components/", "component"), ("composables/", "composable"),
+             ("stores/", "store"), ("utils/", "util"), ("middleware/", "middleware"), ("plugins/", "plugin"),
+             ("app.vue", "app"), ("error.vue", "app")]
+
+
+def kind_rules(src_dir: str = "app") -> list[tuple[str, str]]:
+    pre = "" if src_dir in ("", ".") else src_dir.strip("/") + "/"
+    return [(pre + d, k) for d, k in DIR_KINDS]
+
+
+KIND_RULES = kind_rules("app")
+
+
+def nuxt_route(rel: str, src_dir: str = "app") -> str:
+    """app/pages/shelves/[id]/books/[bookId].vue -> /shelves/:id/books/:bookId (pages/... when srcDir is the root)"""
+    pre = "" if src_dir in ("", ".") else src_dir.strip("/") + "/"
+    p = rel[len(f"{pre}pages/"):]
+    p = re.sub(r"\.vue$", "", p)
+    segs = []
+    parts = p.split("/")
+    for i, s in enumerate(parts):
+        if re.fullmatch(r"\(.*\)", s):
+            continue  # route group
+        if s == "index" and i == len(parts) - 1:
+            continue
+        s = re.sub(r"\[\.\.\.(\w+)\]", r":\1(.*)*", s)
+        s = re.sub(r"\[\[(\w+)\]\]", r":\1?", s)
+        s = re.sub(r"\[(\w+)\]", r":\1", s)
+        segs.append(s)
+    return "/" + "/".join(segs)
+
+
+def find_src_dir(root: Path) -> str:
+    """nuxt.config srcDir, else app/ (Nuxt 4 layout), src/ (when it holds pages/ or app.vue), else the root."""
+    for n in ("nuxt.config.ts", "nuxt.config.js", "nuxt.config.mjs"):
+        f = root / n
+        if f.exists():
+            m = re.search(r"\bsrcDir\s*:\s*['\"`]([^'\"`]+)['\"`]", f.read_text(errors="replace"))
+            if m:
+                d = m.group(1).strip().lstrip("./").rstrip("/") or "."
+                if (root / d).is_dir():
+                    return d
+    for d in ("app", "src"):
+        if any((root / d / x).exists() for x in ("pages", "app.vue", "components", "layouts", "composables")):
+            return d
+    if (root / "app").is_dir() and not (root / "pages").exists():
+        return "app"
+    return "."
+
+
+AUTO_IMPORT_DIRS = ("composables", "utils", "stores")
+# kept out of the generated tsconfig: build output, native shells, static assets (codegraph/presets/nuxt.yaml)
+EXCLUDE = sorted(presets.skip_dirs("nuxt"))
+
+
+def _exports(f: Path) -> list[tuple[str, str]]:
+    """(local name, export name) pairs of a module, by regex (enough for auto-import declarations)."""
+    txt = f.read_text(errors="replace")
+    out = []
+    for m in re.finditer(r"^export\s+(?:async\s+)?(?:function\*?|const|let|var|class)\s+([A-Za-z_$][\w$]*)", txt, re.M):
+        out.append((m.group(1), m.group(1)))
+    for m in re.finditer(r"^export\s*\{([^}]*)\}(?!\s*from)", txt, re.M):
+        for part in m.group(1).split(","):
+            bits = part.strip().split(" as ")
+            if bits[0].strip() and not bits[0].strip().startswith("type "):
+                out.append((bits[-1].strip(), bits[-1].strip()))
+    if re.search(r"^export\s+default\b", txt, re.M):
+        stem = f.stem if f.stem != "index" else f.parent.name
+        name = re.sub(r"[-_.](\w)", lambda m: m.group(1).upper(), stem)
+        out.append((name[:1].lower() + name[1:], "default"))
+    return out
+
+
+def _split_case(s: str) -> list[str]:
+    """scule's splitByCase: `BaseButton` / `base-button` / `base_button` -> [Base, Button] / [base, button]."""
+    out = []
+    for chunk in re.split(r"[-_./]", s):
+        out += [w for w in re.findall(r"[A-Z]+(?=[A-Z][a-z0-9])|[A-Z]?[a-z0-9]+|[A-Z]+", chunk) if w]
+    return out
+
+
+def _component_name(rel_parts: list[str]) -> str:
+    """Nuxt's component name for a file under components/ (resolveComponentNameSegments): the directory words, minus
+    the trailing ones the file name already starts with. base/form/Input.vue -> BaseFormInput, base/BaseButton.vue ->
+    BaseButton, list/Lists.vue -> ListLists, form/input/index.vue -> FormInput, Foo.client.vue -> Foo."""
+    *dirs, file = rel_parts
+    stem = re.sub(r"(\.(client|server))?\.(vue|tsx|jsx|ts|js)$", "", file)
+    file_parts = [] if stem.lower() == "index" and dirs else _split_case(stem)
+    content = "/".join(file_parts).lower()
+    name_parts = [w for d in dirs for w in _split_case(d)]
+    cut, suffix = None, []
+    for i in range(len(dirs) - 1, -1, -1):
+        suffix = [w.lower() for w in _split_case(dirs[i])] + suffix
+        sc = "/".join(suffix)
+        if content and (content == sc or content.startswith(sc + "/")):
+            cut = sum(len(_split_case(d)) for d in dirs[:i])
+    if cut is not None:
+        name_parts = name_parts[:cut]
+    return "".join(w[:1].upper() + w[1:] for w in name_parts + file_parts)
+
+
+def generate_types(root: Path, src_dir: str) -> tuple[Path, dict]:
+    """A stand-in for `nuxi prepare`: tsconfig + auto-import / component declarations in a temp dir."""
+    d = Path(tempfile.mkdtemp(prefix="codegraph-nuxt-"))
+    atexit.register(shutil.rmtree, d, True)
+    src = (root / src_dir).resolve() if src_dir not in ("", ".") else root.resolve()
+    lines, n_imp = ["export {}", "declare global {"], 0
+    seen = set()
+    for sub in AUTO_IMPORT_DIRS:
+        base = src / sub
+        if not base.is_dir():
+            continue
+        files = [f for f in sorted(base.iterdir()) if f.is_file() and re.search(r"\.(ts|js|mjs|mts)$", f.name)
+                 and not re.search(r"\.(test|spec|d)\.", f.name)]
+        files += [i for c in sorted(base.iterdir()) if c.is_dir() for i in (c / "index.ts", c / "index.js") if i.exists()]
+        for f in files:
+            spec = str(f.with_suffix("")).replace("\\", "/")
+            for local, exp in _exports(f):
+                if local in seen:
+                    continue
+                seen.add(local)
+                acc = "['default']" if exp == "default" else f".{exp}"
+                lines.append(f"  const {local}: typeof import('{spec}'){acc}")
+                n_imp += 1
+    nm = root / "node_modules"
+    builtins = 0
+    if (nm / "vue").is_dir():
+        for n in ("ref", "computed", "reactive", "watch", "watchEffect", "onMounted", "onBeforeUnmount", "onUnmounted",
+                  "nextTick", "toRef", "toRefs", "unref", "shallowRef", "readonly"):
+            if n not in seen:
+                lines.append(f"  const {n}: typeof import('vue')['{n}']")
+                builtins += 1
+    if (nm / "nuxt").is_dir():
+        for n in ("useRuntimeConfig", "useFetch", "useLazyFetch", "useAsyncData", "useLazyAsyncData", "useRoute", "useRouter",
+                  "navigateTo", "useState", "useCookie", "useNuxtApp", "defineNuxtPlugin", "defineNuxtRouteMiddleware",
+                  "definePageMeta", "useHead", "useRequestHeaders"):
+            if n not in seen:
+                lines.append(f"  const {n}: typeof import('nuxt/app')['{n}']")
+                builtins += 1
+        if "$fetch" not in seen:
+            lines.append("  const $fetch: typeof import('ofetch')['$fetch']")
+    if (nm / "pinia").is_dir() and "defineStore" not in seen:
+        lines.append("  const defineStore: typeof import('pinia')['defineStore']")
+    lines.append("}")
+    (d / "types").mkdir()
+    (d / "types" / "imports.d.ts").write_text("\n".join(lines) + "\n")
+    (d / "nuxt.d.ts").write_text('/// <reference path="types/imports.d.ts" />\nexport {}\n')
+    comps = ["interface _GlobalComponents {"]
+    n_comp = 0
+    cbase = src / "components"
+    if cbase.is_dir():
+        for f in sorted(cbase.rglob("*")):
+            if f.is_file() and f.suffix in (".vue", ".tsx", ".jsx") and COMMON_SKIP.isdisjoint(f.parts):
+                name = _component_name(list(f.relative_to(cbase).parts))
+                comps.append(f'  {name}: typeof import("{f}")[\'default\']')
+                comps.append(f'  Lazy{name}: LazyComponent<typeof import("{f}")[\'default\']>')
+                n_comp += 1
+    comps.append("}")
+    (d / "types" / "components.d.ts").write_text("\n".join(comps) + "\n")
+    # the user's tsconfig (minus its reference to .nuxt) still contributes compilerOptions such as extra paths
+    user_opts = {}
+    try:
+        raw = re.sub(r"(?m)^\s*//.*$", "", (root / "tsconfig.json").read_text())
+        user_opts = (json.loads(re.sub(r",(\s*[}\]])", r"\1", raw)) or {}).get("compilerOptions") or {}
+    except Exception:
+        pass
+    paths = {k: [str((root / x).resolve()) for x in v] for k, v in (user_opts.get("paths") or {}).items()}
+    for alias, target in (("~", src), ("@", src), ("~~", root.resolve()), ("@@", root.resolve())):
+        paths.setdefault(f"{alias}/*", [f"{target}/*"])
+        paths.setdefault(alias, [str(target)])
+    cfg = {"compilerOptions": {"target": "ESNext", "module": "ESNext", "moduleResolution": "Bundler", "jsx": "preserve",
+                               "allowJs": True, "checkJs": False, "strict": False, "skipLibCheck": True, "noEmit": True,
+                               "resolveJsonModule": True, "esModuleInterop": True, "baseUrl": str(root.resolve()),
+                               "paths": paths},
+           "include": [str(d / "nuxt.d.ts"), f"{src}/**/*"],
+           "exclude": [str(root.resolve() / x) for x in EXCLUDE] + [f"{src}/**/*.d.ts"]}
+    (d / "tsconfig.app.json").write_text(json.dumps(cfg, indent=1))
+    return d, {"auto_imports": n_imp, "builtins": builtins, "components": n_comp}
+
+
+def flatten(d, prefix=""):
+    if isinstance(d, dict):
+        for k, v in d.items():
+            yield from flatten(v, f"{prefix}.{k}" if prefix else k)
+    else:
+        yield prefix
+
+
+class NuxtPlugin(FrameworkPlugin):
+    name, language = "nuxt", "typescript"
+
+    def detect(self, project: Project) -> bool:
+        return any(project.exists(n) for n in ("nuxt.config.ts", "nuxt.config.js", "nuxt.config.mjs"))
+
+    def register_hooks(self, ctx) -> None:
+        root = ctx.project.root
+        cfg = ctx.extractor_cfg
+        self.src_dir = find_src_dir(root)
+        self.generated = {}
+        tsc = next((t for t in (".nuxt/tsconfig.app.json", ".nuxt/tsconfig.json") if (root / t).exists()), None)
+        self.prepared = "nuxi" if tsc else "generated"
+        if tsc:
+            cfg["tsconfig"] = tsc
+            cfg["components_dts"] = str(root / ".nuxt" / "types" / "components.d.ts")
+            if not Path(cfg["components_dts"]).exists() and (root / ".nuxt" / "components.d.ts").exists():
+                cfg["components_dts"] = str(root / ".nuxt" / "components.d.ts")
+        else:
+            d, self.generated = generate_types(root, self.src_dir)
+            cfg["tsconfig"] = str(d / "tsconfig.app.json")
+            cfg["components_dts"] = str(d / "types" / "components.d.ts")
+            cfg["walk_src"] = True
+            cfg["generated_types"] = True
+            print(f"nuxt: no .nuxt/ in {root.name} (run `npx nuxi prepare` for Nuxt's own generated types); using "
+                  f"generated stand-ins: {self.generated['auto_imports']} auto-imports, {self.generated['components']} "
+                  f"components{'' if (root / 'node_modules').is_dir() else ', no node_modules so Vue/Nuxt built-ins stay unresolved'}",
+                  file=sys.stderr)
+        cfg["kinds"] = kind_rules(self.src_dir)
+        cfg["src_dirs"] = [self.src_dir]
+
+    def contribute(self, project: Project, builder: GraphBuilder, ctx) -> dict:
+        st = {"prepared": self.prepared, "src_dir": self.src_dir, "pages": 0, "layouts": 0, "ui_global": 0,
+              "i18n_keys_used": 0, "i18n_keys_defined": 0}
+        if self.generated:
+            st["generated_types"] = self.generated
+        if not ctx or not ctx.facts:
+            return {**st, "status": "no facts"}
+        layouts = {}
+        for n in builder.nodes.values():
+            if n.lang != "ts" or not n.file:
+                continue
+            if n.kind == "page":
+                route = nuxt_route(n.file, self.src_dir)
+                n.attrs["route"] = route
+                n.name = route
+                n.fqn = route
+                n.entry_kind = "ui_page"
+                st["pages"] += 1
+            elif n.kind == "layout":
+                layouts[Path(n.file).stem] = n.id
+                n.entry_kind = "ui_global"
+                st["layouts"] += 1
+            elif n.kind == "app" or (n.kind == "module" and (n.attrs.get("file_kind") == "plugin" or
+                                                             (n.attrs.get("file_kind") == "middleware" and ".global." in n.file))):
+                n.entry_kind = "ui_global"
+                st["ui_global"] += 1
+        meta = ctx.facts.get("page_meta") or {}
+        for n in list(builder.nodes.values()):
+            if n.kind != "page":
+                continue
+            lay = (meta.get(n.file) or {}).get("layout") or "default"
+            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)
+        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"], [])})
+            builder.add_edge(u["src"], nid, "USES_I18N", file=u["file"], line=u["line"],
+                             confidence="exact" if u["key"] in defined else "heuristic")
+        st["i18n_keys_used"] = len({u["key"] for u in ctx.facts.get("i18n") or []})
+        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

codegraph/plugins/php/extractor/composer.json

@@ -0,0 +1,5 @@
+{
+    "require": {
+        "nikic/php-parser": "^5.4"
+    }
+}