@event4u/agent-config 17.2.0 → 17.3.0

package/src/scripts/code_graph/providers/go_http.ts

@@ -0,0 +1,121 @@
+/**
+ * Go HTTP routers: a registration on a router value → the handler function.
+ *
+ *   http.HandleFunc("/x", h) · mux.HandleFunc("GET /x", h) · mux.Handle("/x", h)   net/http (1.22 verb patterns)
+ *   r.GET("/x", h) · g := r.Group("/api"); g.POST("/y", h)                          Gin (group prefix)
+ *   e.GET("/x", h)                                                                    Echo
+ *   r.Get("/x", h)                                                                    chi
+ *
+ * A receiver must be a router the same function states: assigned from a router
+ * constructor or a `.Group("/p")` of one, or a parameter of a router type; the
+ * `http` package itself when the file imports `net/http`. So `cache.Get("/x")`
+ * is no route. A handler resolves as the file names it: a function of the same
+ * file, then of the same directory (the Go package); `pkg.F` through the
+ * file's import of an in-repo package directory; `v.m` to the one method named
+ * `m` in the package. Anything else — a closure, `http.HandlerFunc(f)` — gets
+ * a route with no target. chi's `r.Route("/p", func…)` nesting is not followed.
+ *
+ * Detection is every `go.mod`: `net/http` is the standard library and declares
+ * no requirement, and a Gin, Echo or chi project carries a `go.mod` already, so
+ * the third-party modules need no marker of their own.
+ */
+import * as path from 'node:path';
+
+import { goRoots } from './shared/detect.js';
+import { joinRoute, lastArgName } from './shared/extractors.js';
+import { type Kit, lineIndex, makeKit, packageSymbol } from './shared/kit.js';
+import type { ConventionProvider } from './types.js';
+
+const CONSTRUCTOR =
+    /\b(?<v>\w+)\s*:?=\s*&?(?:chi\.NewRouter|chi\.NewMux|gin\.Default|gin\.New|echo\.New|http\.NewServeMux|mux\.NewRouter)\(\)/g;
+const GROUP = /\b(?<v>\w+)\s*:?=\s*(?<parent>\w+)\.Group\(\s*"(?<p>[^"]*)"/g;
+const PARAM = /\b(?<v>\w+)\s+\*?(?:gin\.(?:Engine|RouterGroup|IRouter|IRoutes)|chi\.(?:Router|Mux)|http\.ServeMux|echo\.(?:Echo|Group)|mux\.Router)\b/g;
+const REGISTER =
+    /\b(?<recv>\w+)\.(?<m>HandleFunc|Handle|GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD|Any|Get|Post|Put|Delete|Patch|Options|Head)\(\s*"(?:(?<pverb>[A-Z]+)\s+)?(?<path>\/[^"]*)"\s*,(?=(?<rest>[\s\S]{0,300}))/g;
+const IMPORT = /^\s*(?:import\s+)?(?<alias>[\w.]+\s+)?"(?<spec>[^"]+)"\s*$/gm;
+
+/** Local package name → import path, for the imports a file states. */
+function imports(src: string): Map<string, string> {
+    const out = new Map<string, string>();
+    const blocks = [...src.matchAll(/^import\s*\(([\s\S]*?)^\)/gm)].map((m) => m[1] as string);
+    const singles = [...src.matchAll(/^import\s+([\w.]+\s+)?("[^"]+")\s*$/gm)].map((m) => `${m[1] ?? ''}${m[2]}`);
+    for (const text of [...blocks, ...singles]) {
+        for (const m of text.matchAll(IMPORT)) {
+            const spec = m.groups?.['spec'] as string;
+            const segs = spec.split('/');
+            const last = segs[segs.length - 1] as string;
+            const name = m.groups?.['alias']?.trim() ?? (/^v\d+$/.test(last) && segs.length > 1 ? (segs[segs.length - 2] as string) : last);
+            out.set(name, spec);
+        }
+    }
+    return out;
+}
+
+/** The one in-repo package directory an import path names, under a provider root. */
+function packageDir(kit: Kit, spec: string): string | null {
+    const dirs = new Set(kit.filesWithExt('.go').map((f) => path.posix.dirname(f.path)));
+    const hits = [...dirs].filter((d) =>
+        kit.roots.some((root) => {
+            const rel = root === '' ? d : d.startsWith(`${root}/`) ? d.slice(root.length + 1) : null;
+            return rel !== null && rel !== '.' && (spec === rel || spec.endsWith(`/${rel}`));
+        }),
+    );
+    return hits.length === 1 ? (hits[0] as string) : null;
+}
+
+function resolveHandler(kit: Kit, file: string, rest: string, imported: Map<string, string>): string | null {
+    const name = lastArgName(rest);
+    if (!name) return null;
+    const [head, member] = name.split('.') as [string, string | undefined];
+    if (!member) {
+        const local = kit.nodesInFile(file).find((n) => n.kind === 'function' && n.label === head);
+        return local ? local.id : packageSymbol(kit, file, head, ['function']);
+    }
+    const spec = imported.get(head);
+    if (spec) {
+        const dir = packageDir(kit, spec);
+        return dir ? packageSymbol(kit, `${dir}/_.go`, member, ['function']) : null;
+    }
+    return packageSymbol(kit, file, member, ['method']);
+}
+
+export const goHttpProvider: ConventionProvider = {
+    id: 'go-http',
+    detect: (probe) => goRoots(probe, ['module']),
+    build: (input) => {
+        const kit = makeKit(input);
+        for (const f of kit.filesWithExt('.go')) {
+            const at = lineIndex(f.source);
+            const imported = imports(f.source);
+            const scope = (index: number): string => kit.enclosing(f.path, at(index));
+            const routers = new Map<string, string>();
+            const key = (index: number, v: string): string => `${scope(index)}\0${v}`;
+            const found = [
+                ...[...f.source.matchAll(CONSTRUCTOR)].map((m) => ({ m, parent: undefined as string | undefined })),
+                ...[...f.source.matchAll(PARAM)].map((m) => ({ m, parent: undefined as string | undefined })),
+                ...[...f.source.matchAll(GROUP)].map((m) => ({ m, parent: m.groups?.['parent'] })),
+            ].sort((a, b) => (a.m.index as number) - (b.m.index as number));
+            for (const { m, parent } of found) {
+                const v = m.groups?.['v'] as string;
+                if (parent === undefined) {
+                    routers.set(key(m.index as number, v), '');
+                    continue;
+                }
+                const base = routers.get(key(m.index as number, parent));
+                if (base !== undefined) routers.set(key(m.index as number, v), joinRoute(base, m.groups?.['p']));
+            }
+            const httpPackage = [...imported].find(([, spec]) => spec === 'net/http')?.[0];
+            for (const m of f.source.matchAll(REGISTER)) {
+                const recv = m.groups?.['recv'] as string;
+                const method = m.groups?.['m'] as string;
+                const prefix = recv === httpPackage && /^Handle(Func)?$/.test(method) ? '' : routers.get(key(m.index as number, recv));
+                if (prefix === undefined) continue;
+                const verb = m.groups?.['pverb'] ?? (/^(HandleFunc|Handle|Any)$/.test(method) ? 'ANY' : method.toUpperCase());
+                const id = kit.route(f.path, verb, joinRoute(prefix, m.groups?.['path']), at(m.index as number));
+                const target = resolveHandler(kit, f.path, m.groups?.['rest'] ?? '', imported);
+                if (target) kit.emit(id, target, 'routes-to', 'route-table');
+            }
+        }
+        return kit.result();
+    },
+};

package/src/scripts/code_graph/providers/index.ts

@@ -0,0 +1,101 @@
+/**
+ * The convention-provider registry (ADR-298). The only module the graph core
+ * imports provider code through; adding a framework is an entry here, never a
+ * branch in the build.
+ */
+import type { FileRole } from '../map_model.js';
+import type { ActiveProviderRecord } from '../types.js';
+import { angularProvider } from './angular.js';
+import { aspnetcoreProvider } from './aspnetcore.js';
+import { djangoProvider } from './django.js';
+import { expressProvider } from './express.js';
+import { fastapiProvider } from './fastapi.js';
+import { flaskProvider } from './flask.js';
+import { goHttpProvider } from './go_http.js';
+import { laravelProvider } from './laravel.js';
+import { nestjsProvider } from './nestjs.js';
+import { nextjsProvider } from './nextjs.js';
+import { nuxtProvider } from './nuxt.js';
+import { reactRouterProvider } from './react-router.js';
+import { springProvider } from './spring.js';
+import { sqlalchemyProvider } from './sqlalchemy.js';
+import { sveltekitProvider } from './sveltekit.js';
+import { symfonyProvider } from './symfony.js';
+import { typeormProvider } from './typeorm.js';
+import { vueRouterProvider } from './vue-router.js';
+import { wordpressProvider } from './wordpress.js';
+import type { ConventionProvider, ProjectProbe } from './types.js';
+
+export type { ConventionProvider, ProjectProbe, ProviderInput, ProviderResult } from './types.js';
+export { EMPTY_PROBE } from './types.js';
+export { CATALOG, type CatalogRow, catalogRow, type CoverageStatus } from './catalog.js';
+
+/** Registration order is execution order; ids are unique. */
+export const PROVIDERS: readonly ConventionProvider[] = [
+    laravelProvider,
+    expressProvider,
+    springProvider,
+    goHttpProvider,
+    symfonyProvider,
+    wordpressProvider,
+    fastapiProvider,
+    flaskProvider,
+    djangoProvider,
+    sqlalchemyProvider,
+    reactRouterProvider,
+    nextjsProvider,
+    nestjsProvider,
+    angularProvider,
+    vueRouterProvider,
+    nuxtProvider,
+    sveltekitProvider,
+    typeormProvider,
+    aspnetcoreProvider,
+];
+
+/** Every marker basename a registered provider asks the probe to record. */
+export const PROBE_MARKERS: ReadonlySet<string> = new Set(PROVIDERS.flatMap((p) => p.markers ?? []));
+
+export interface ActiveProvider {
+    provider: ConventionProvider;
+    roots: string[];
+}
+
+/** The providers whose markers the probe carries, each with the package roots it applies to. */
+export function activeProviders(probe: ProjectProbe, registry: readonly ConventionProvider[] = PROVIDERS): ActiveProvider[] {
+    const out: ActiveProvider[] = [];
+    for (const provider of registry) {
+        const roots = provider.detect(probe);
+        if (roots.length > 0) out.push({ provider, roots });
+    }
+    return out;
+}
+
+/**
+ * The first role a provider gives this path. With `active` (the graph's record),
+ * only those providers are asked, each about the path relative to its package
+ * roots; without it, every registered provider is asked about the path as is.
+ */
+export function providerRole(
+    p: string,
+    active?: readonly ActiveProviderRecord[],
+    registry: readonly ConventionProvider[] = PROVIDERS,
+): FileRole | undefined {
+    if (!active) {
+        for (const provider of registry) {
+            const role = provider.roleOf?.(p);
+            if (role) return role;
+        }
+        return undefined;
+    }
+    for (const rec of active) {
+        const provider = registry.find((x) => x.id === rec.id);
+        if (!provider?.roleOf) continue;
+        for (const root of rec.roots) {
+            if (root !== '' && !p.startsWith(`${root}/`)) continue;
+            const role = provider.roleOf(root === '' ? p : p.slice(root.length + 1));
+            if (role) return role;
+        }
+    }
+    return undefined;
+}

package/src/scripts/code_graph/{laravel_overlay.ts → providers/laravel.ts}

@@ -15,9 +15,13 @@
  * rule cannot settle — a closure handler, a view name built at runtime — is
  * counted in `stats`, never guessed.
  */
-import type { SourceFile } from './build.js';
-import { resolvePsr4, type ResolutionConfig } from './resolution_tiers.js';
-import type { CodeEdge, CodeNode } from './types.js';
+import * as path from 'node:path';
+
+import type { SourceFile } from '../build.js';
+import type { FileRole } from '../map_model.js';
+import { psr4RulesFrom, resolvePsr4, type ResolutionConfig } from '../resolution_tiers.js';
+import type { CodeEdge, CodeNode } from '../types.js';
+import type { ConventionProvider, ProjectProbe } from './types.js';
 
 export interface LaravelOverlayStats {
     routes: number;
@@ -172,6 +176,8 @@ export function buildLaravelOverlay(
     files: readonly SourceFile[],
     baseNodes: readonly CodeNode[],
     resolution: ResolutionConfig,
+    /** The package root with a trailing slash (`''` at the repository root). */
+    prefix = '',
 ): LaravelOverlay {
     const stats: LaravelOverlayStats = {
         routes: 0,
@@ -225,7 +231,8 @@ export function buildLaravelOverlay(
     const viewFile = (name: string): string | null => {
         if (name.includes('::')) return null;
         const rel = name.replace(/\./g, '/');
-        for (const c of [`resources/views/${rel}.blade.php`, `resources/views/${rel}.php`, `resources/views/${rel}/index.blade.php`]) {
+        const views = `${prefix}resources/views/`;
+        for (const c of [`${views}${rel}.blade.php`, `${views}${rel}.php`, `${views}${rel}/index.blade.php`]) {
             if (fileIds.has(c)) return c;
         }
         return null;
@@ -234,7 +241,7 @@ export function buildLaravelOverlay(
 
     // Routes.
     let routeOrdinal = new Map<string, number>();
-    for (const f of php.filter((x) => x.path.startsWith('routes/'))) {
+    for (const f of php.filter((x) => x.path.startsWith(`${prefix}routes/`))) {
         const src = f.source;
         const at = lineIndex(src);
         const scope = phpScope(src);
@@ -433,12 +440,47 @@ export function buildLaravelOverlay(
             const file = classFile(fq);
             const target = file ? `${file}#${shortName(fq)}` : null;
             if (!target || !nodeById.has(target)) continue;
-            emit(enclosing(d.file.path, at(m.index as number)), target, 'relates', 'eloquent-relation');
+            emit(enclosing(d.file.path, at(m.index as number)), target, 'relates', 'orm-relation');
             stats.relations += 1;
         }
     }
 
-    const routesFiles = new Set(php.filter((x) => x.path.startsWith('routes/')).map((x) => x.path));
+    // Which models a method names. A controller imports its models once per
+    // file, so a route's tables are read per handler from these edges rather
+    // than from the file's `use` lines (which attribute every model of the file
+    // to every route the file serves).
+    const modelIds = new Set<string>();
+    for (const [id, d] of classDecl) {
+        const name = id.split('#')[1] as string;
+        if (modelNames.has(d.parent) && !MODEL_BASES.has(name) && nodeById.has(id)) modelIds.add(id);
+    }
+    if (modelIds.size > 0) {
+        for (const f of php) {
+            if (blade(f.path)) continue;
+            const scope = phpScope(f.source);
+            const lines = f.source.split('\n');
+            for (const n of symbolsByFile.get(f.path) ?? []) {
+                if (n.kind !== 'method') continue;
+                const [s0, , e0] = n.source_location as [number, number, number, number];
+                // Strings and comments name words, not classes: `'User not found'` is no reference.
+                const body = lines
+                    .slice(s0 - 1, e0)
+                    .join('\n')
+                    .replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*|#[^\n[]*$/gm, ' ')
+                    .replace(/'(?:[^'\\\n]|\\.)*'|"(?:[^"\\\n]|\\.)*"/g, "''");
+                const own = n.id.split('::')[0];
+                for (const token of new Set([...body.matchAll(/\b([A-Z]\w*)\b/g)].map((m) => m[1] as string))) {
+                    const fq = qualify(token, scope);
+                    const file = classFile(fq);
+                    const target = file ? `${file}#${shortName(fq)}` : null;
+                    if (!target || target === own || !modelIds.has(target)) continue;
+                    emit(n.id, target, 'uses', scope.uses.has(token) ? 'import-specifier' : 'psr4');
+                }
+            }
+        }
+    }
+
+    const routesFiles = new Set(php.filter((x) => x.path.startsWith(`${prefix}routes/`)).map((x) => x.path));
     const dropEdge = (e: CodeEdge): boolean => {
         if (e.relation !== 'calls' || e.resolved_via === 'same-file') return false;
         const src = nodeById.get(e.source);
@@ -452,3 +494,67 @@ export function buildLaravelOverlay(
 
     return { nodes, edges, dropEdge, stats };
 }
+
+/** A composer manifest that pulls in the framework or any of its components. */
+function requiresLaravel(manifest: string): boolean {
+    try {
+        const j = JSON.parse(manifest) as { require?: Record<string, string>; 'require-dev'?: Record<string, string> };
+        const names = [...Object.keys(j.require ?? {}), ...Object.keys(j['require-dev'] ?? {})];
+        return names.some((n) => n === 'laravel/framework' || n.startsWith('illuminate/'));
+    } catch {
+        return false;
+    }
+}
+
+function detectLaravel(probe: ProjectProbe): string[] {
+    const roots = new Set<string>();
+    const dirOf = (p: string): string => {
+        const d = path.posix.dirname(p);
+        return d === '.' ? '' : d;
+    };
+    for (const [p, text] of probe.manifests) {
+        if (path.posix.basename(p) === 'composer.json' && requiresLaravel(text)) roots.add(dirOf(p));
+    }
+    for (const p of probe.markers) if (path.posix.basename(p) === 'artisan') roots.add(dirOf(p));
+    return [...roots].sort();
+}
+
+function laravelRole(p: string): FileRole | undefined {
+    if (path.posix.basename(p).endsWith('.blade.php') || p.startsWith('resources/views/') || p.includes('/resources/views/')) return 'view';
+    if (p.startsWith('routes/') || p === 'public/index.php' || p === 'artisan') return 'entry';
+    return undefined;
+}
+
+export const laravelProvider: ConventionProvider = {
+    id: 'laravel',
+    markers: ['artisan'],
+    detect: detectLaravel,
+    build: ({ files, baseNodes, resolution, roots, manifests }) => {
+        // One overlay per package root: a Laravel app under `backend/` keeps its
+        // routes, views and PSR-4 map there, not at the repository root.
+        const nodes = new Map<string, CodeNode>();
+        const edges = new Map<string, CodeEdge>();
+        const contests: Array<(e: CodeEdge) => boolean> = [];
+        for (const root of roots) {
+            const prefix = root === '' ? '' : `${root}/`;
+            let config = resolution;
+            if (root !== '') {
+                let composer: unknown = null;
+                try {
+                    composer = JSON.parse(manifests.get(`${prefix}composer.json`) ?? 'null');
+                } catch {
+                    composer = null;
+                }
+                const own = psr4RulesFrom(composer).map((r) => ({ ...r, dirs: r.dirs.map((d) => `${prefix}${d}`) }));
+                config = { ...resolution, psr4: [...own, ...resolution.psr4] };
+            }
+            const scoped = root === '' ? files : files.filter((f) => f.path.startsWith(prefix));
+            const o = buildLaravelOverlay(scoped, baseNodes, config, prefix);
+            for (const n of o.nodes) if (!nodes.has(n.id)) nodes.set(n.id, n);
+            for (const e of o.edges) edges.set(`${e.source}\0${e.relation}\0${e.target}`, e);
+            contests.push(o.dropEdge);
+        }
+        return { nodes: [...nodes.values()], edges: [...edges.values()], contest: (e) => contests.some((c) => c(e)) };
+    },
+    roleOf: laravelRole,
+};

package/src/scripts/code_graph/providers/nestjs.ts

@@ -0,0 +1,34 @@
+/**
+ * NestJS: `@Controller('users')` + `@Get(':id')` → `GET /users/:id`
+ * --routes-to--> the decorated method; `constructor(private readonly s: UsersService)`
+ * in an `@Injectable()` / `@Controller()` class → class --injects--> UsersService
+ * when the file names that class. An object-form prefix (`@Controller({ path })`),
+ * an array of paths, and a custom provider token (`@Inject('X')`) are not
+ * followed; a global prefix set in `main.ts` is not applied.
+ */
+import { npmRoots } from './shared/detect.js';
+import { annotationRoutes } from './shared/extractors.js';
+import { constructorInjection } from './shared/js.js';
+import { makeKit } from './shared/kit.js';
+import type { ConventionProvider } from './types.js';
+
+const EXTS = ['.ts', '.js'];
+
+export const nestjsProvider: ConventionProvider = {
+    id: 'nestjs',
+    detect: (probe) => npmRoots(probe, ['@nestjs/core']),
+    build: (input) => {
+        const kit = makeKit(input);
+        annotationRoutes(kit, {
+            exts: EXTS,
+            route: /@(?<verb>Get|Post|Put|Patch|Delete|Options|Head|All)\(\s*(?:(['"`])(?<path>[^'"`]*)\2\s*)?\)/g,
+            verb: (m) => (m.groups?.['verb'] === 'All' ? 'ANY' : (m.groups?.['verb'] as string)),
+            prefix: /@Controller\(\s*(?:(['"`])(?<path>[^'"`]*)\1\s*)?\)/g,
+        });
+        constructorInjection(kit, {
+            exts: EXTS,
+            classDecorator: /@(?:Injectable|Controller|Resolver|WebSocketGateway)\(/,
+        });
+        return kit.result();
+    },
+};

package/src/scripts/code_graph/providers/nextjs.ts

@@ -0,0 +1,91 @@
+/**
+ * Next.js, both routers, under `app/` or `src/app/` and `pages/` or `src/pages/`
+ * of a package root:
+ *
+ *   app/a/[id]/page.tsx     PAGE /a/[id]           --routes-to--> the page module
+ *   app/api/x/route.ts      GET /api/x · POST …    --routes-to--> the exported verb function
+ *   app/a/layout.tsx        --includes-->           every page below its directory
+ *   pages/a.tsx             PAGE /a                --routes-to--> the page module
+ *   pages/api/x.ts          ROUTE /api/x           --routes-to--> the API module
+ *
+ * Route ids match the default pass's, so a page drawn here replaces the generic
+ * one. Route groups and parallel slots drop out of the path; a private `_dir`
+ * is no route. A route module re-exporting a verb (`export { h as GET }`) is
+ * not followed, and the default pass still adds its generic `ROUTE` node for a
+ * `route.ts`.
+ */
+import * as path from 'node:path';
+
+import { npmRoots } from './shared/detect.js';
+import { cleanRoute, exportedVerbRoutes, underRoot } from './shared/js.js';
+import { makeKit } from './shared/kit.js';
+import type { ConventionProvider } from './types.js';
+
+const PAGE_EXTS = new Set(['.tsx', '.jsx', '.ts', '.js', '.mdx']);
+
+interface Classified {
+    kind: 'page' | 'route' | 'layout' | 'pages-page' | 'pages-api';
+    /** The directory the router starts at, repo-relative. */
+    base: string;
+    segments: string[];
+}
+
+function classify(roots: readonly string[], p: string): Classified | null {
+    const at = underRoot(roots, p);
+    if (!at) return null;
+    const ext = path.posix.extname(p);
+    if (!PAGE_EXTS.has(ext)) return null;
+    const segs = at.rel.split('/');
+    const lead = segs[0] === 'src' ? 1 : 0;
+    const dir = segs[lead];
+    const prefix = [at.root, ...segs.slice(0, lead + 1)].filter(Boolean).join('/');
+    const stem = (segs[segs.length - 1] as string).slice(0, -ext.length);
+    const inner = segs.slice(lead + 1, -1);
+    if (dir === 'app') {
+        if (inner.some((s) => s.startsWith('_'))) return null;
+        if (stem === 'page') return { kind: 'page', base: prefix, segments: inner };
+        if (stem === 'route' && ext !== '.mdx') return { kind: 'route', base: prefix, segments: inner };
+        if (stem === 'layout') return { kind: 'layout', base: prefix, segments: inner };
+        return null;
+    }
+    if (dir === 'pages' && segs.length > lead + 1) {
+        if (stem.startsWith('_')) return null;
+        const rest = [...inner, stem];
+        return { kind: rest[0] === 'api' ? 'pages-api' : 'pages-page', base: prefix, segments: rest };
+    }
+    return null;
+}
+
+export const nextjsProvider: ConventionProvider = {
+    id: 'nextjs',
+    detect: (probe) => npmRoots(probe, ['next']),
+    build: (input) => {
+        const kit = makeKit(input);
+        const pages: string[] = [];
+        const layouts: string[] = [];
+        for (const p of kit.paths) {
+            const c = classify(kit.roots, p);
+            if (!c) continue;
+            const route = cleanRoute(c.segments);
+            if (c.kind === 'layout') {
+                layouts.push(p);
+            } else if (c.kind === 'route') {
+                if (kit.fileIds.has(p)) exportedVerbRoutes(kit, p, route);
+            } else {
+                kit.fileNode(p);
+                const id = kit.route(p, c.kind === 'pages-api' ? 'ROUTE' : 'PAGE', route, 1);
+                kit.emit(id, p, 'routes-to', 'route-table');
+                if (c.kind === 'page') pages.push(p);
+            }
+        }
+        for (const layout of layouts) {
+            const dir = `${path.posix.dirname(layout)}/`;
+            for (const page of pages) {
+                if (!page.startsWith(dir)) continue;
+                kit.fileNode(layout);
+                kit.emit(layout, page, 'includes', 'directive-scan');
+            }
+        }
+        return kit.result();
+    },
+};

package/src/scripts/code_graph/providers/nuxt.ts

@@ -0,0 +1,55 @@
+/**
+ * Nuxt file routing under a package root (or its `app/` directory):
+ *
+ *   pages/a/[id].vue            PAGE /a/[id]         --routes-to--> the page component
+ *   server/api/users.get.ts     GET /api/users       --routes-to--> the handler module
+ *   server/routes/feed.ts       ROUTE /feed          --routes-to--> the handler module
+ *
+ * Unlike the default pass, no `index` page is required. Route ids match the
+ * default's, so a page drawn here replaces the generic one. Route middleware,
+ * `definePageMeta` path overrides and catch-all rewrites are not followed.
+ */
+import * as path from 'node:path';
+
+import { npmRoots } from './shared/detect.js';
+import { cleanRoute, HTTP_VERBS, underRoot } from './shared/js.js';
+import { makeKit } from './shared/kit.js';
+import type { ConventionProvider } from './types.js';
+
+const SERVER_EXTS = new Set(['.ts', '.js', '.mjs']);
+
+function classify(roots: readonly string[], p: string): { verb: string; route: string } | null {
+    const at = underRoot(roots, p);
+    if (!at) return null;
+    const segs = at.rel.split('/');
+    const lead = segs[0] === 'app' && segs[1] === 'pages' ? 1 : 0;
+    const ext = path.posix.extname(p);
+    const stem = (segs[segs.length - 1] as string).slice(0, -ext.length);
+    if (segs[lead] === 'pages' && segs.length > lead + 1 && ext === '.vue') {
+        return { verb: 'PAGE', route: cleanRoute([...segs.slice(lead + 1, -1), stem]) };
+    }
+    if (segs[0] === 'server' && (segs[1] === 'api' || segs[1] === 'routes') && segs.length > 2 && SERVER_EXTS.has(ext)) {
+        const dot = /^(?<name>.+)\.(?<verb>get|post|put|patch|delete|head|options)$/.exec(stem);
+        const verb = dot ? (dot.groups?.['verb'] as string).toUpperCase() : 'ROUTE';
+        const name = dot ? (dot.groups?.['name'] as string) : stem;
+        if (!(verb === 'ROUTE' || (HTTP_VERBS as readonly string[]).includes(verb))) return null;
+        const prefix = segs[1] === 'api' ? ['api'] : [];
+        return { verb, route: cleanRoute([...prefix, ...segs.slice(2, -1), name]) };
+    }
+    return null;
+}
+
+export const nuxtProvider: ConventionProvider = {
+    id: 'nuxt',
+    detect: (probe) => npmRoots(probe, ['nuxt']),
+    build: (input) => {
+        const kit = makeKit(input);
+        for (const p of kit.paths) {
+            const r = classify(kit.roots, p);
+            if (!r) continue;
+            kit.fileNode(p);
+            kit.emit(kit.route(p, r.verb, r.route, 1), p, 'routes-to', 'route-table');
+        }
+        return kit.result();
+    },
+};

package/src/scripts/code_graph/providers/react-router.ts

@@ -0,0 +1,58 @@
+/**
+ * React Router: `<Route path="/x" element={<X />} />` (or `component={X}`) and
+ * route objects `{ path: '/x', element: <X />, Component: X, lazy: () => import('./x') }`
+ * → a PAGE route --routes-to--> the component the file names or the module it
+ * imports lazily. A `<Route>` without `path` (an index or layout route) and an
+ * object without a component key are no routes. Nested `children` paths are
+ * not joined to their parent's.
+ */
+import { npmRoots } from './shared/detect.js';
+import { joinRoute } from './shared/extractors.js';
+import { componentTarget, routeObjects } from './shared/js.js';
+import { type Kit, lineIndex, makeKit } from './shared/kit.js';
+import type { ConventionProvider } from './types.js';
+
+const EXTS = ['.tsx', '.jsx', '.ts', '.js'];
+
+/** The attribute text of a JSX tag opened at `from`, up to its `>` outside braces. */
+function attributes(src: string, from: number): string {
+    let depth = 0;
+    for (let i = from; i < src.length && i < from + 2000; i++) {
+        const c = src[i];
+        if (c === '{') depth += 1;
+        else if (c === '}') depth -= 1;
+        else if (c === '>' && depth === 0) return src.slice(from, i);
+    }
+    return '';
+}
+
+function jsxRoutes(kit: Kit): number {
+    let count = 0;
+    for (const f of kit.filesWithExt('.tsx', '.jsx', '.js')) {
+        const at = lineIndex(f.source);
+        for (const m of f.source.matchAll(/<Route\b/g)) {
+            const attrs = attributes(f.source, (m.index as number) + m[0].length);
+            const p = /\bpath\s*=\s*\{?\s*(['"`])([^'"`$]*)\1/.exec(attrs);
+            if (!p) continue;
+            const id = kit.route(f.path, 'PAGE', joinRoute(p[2]), at(m.index as number));
+            const el = /\belement\s*=\s*\{\s*(<\s*[A-Z][\w$]*)/.exec(attrs);
+            const comp = /\b(?:component|Component)\s*=\s*\{\s*([A-Za-z_$][\w$]*)\s*\}/.exec(attrs);
+            const value = el?.[1] ?? comp?.[1];
+            const target = value ? componentTarget(kit, f.path, value) : null;
+            if (target) kit.emit(id, target, 'routes-to', 'route-table');
+            count += 1;
+        }
+    }
+    return count;
+}
+
+export const reactRouterProvider: ConventionProvider = {
+    id: 'react-router',
+    detect: (probe) => npmRoots(probe, ['react-router', 'react-router-dom']),
+    build: (input) => {
+        const kit = makeKit(input);
+        jsxRoutes(kit);
+        routeObjects(kit, { exts: EXTS, componentKeys: ['element', 'Component', 'lazy'] });
+        return kit.result();
+    },
+};