@event4u/agent-config 17.2.1 → 17.4.0

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

@@ -0,0 +1,299 @@
+/**
+ * The coverage catalog (ADR-298 § 6): for every provider, what it resolves and
+ * how far that is proven — so nothing reads as supported because it is
+ * detected. Stacks not covered yet stand here as `planned`, never silently
+ * absent.
+ *
+ *   detected  markers recognised, no relation resolved
+ *   partial   relations resolved and proven by synthetic positive and negative oracles
+ *   verified  partial, plus a reading on a real repository
+ *   deep      verified across every relation the framework has (none yet)
+ *   planned   on the coverage list, not built; the generic default still runs
+ */
+import type { Relation } from '../types.js';
+
+export type CoverageStatus = 'detected' | 'partial' | 'verified' | 'deep' | 'planned';
+
+export interface CatalogRow {
+    /** The registered provider id, or a planned id. */
+    id: string;
+    /** What a person calls it. */
+    name: string;
+    language: string;
+    /** How it is detected (manifest entries or marker files). */
+    markers: string;
+    relations: readonly Relation[];
+    status: CoverageStatus;
+    /** The synthetic fixture its oracles run on. */
+    fixture: string | null;
+    /** The usage reading that put it on the coverage list. */
+    usage: string;
+    /** What it does not follow, said plainly. */
+    limits?: string;
+}
+
+const SO = 'Stack Overflow Developer Survey, web frameworks (year as recorded in the supplied plans; not re-read in this run)';
+
+export const CATALOG: readonly CatalogRow[] = [
+    {
+        id: 'laravel',
+        name: 'Laravel',
+        language: 'PHP',
+        markers: 'composer.json requires laravel/framework or an illuminate/* package; an artisan file',
+        relations: ['routes-to', 'renders', 'includes', 'reads', 'migrates', 'persists', 'relates', 'uses'],
+        status: 'verified',
+        fixture: 'tests/scripts/code_graph_provider_laravel.test.ts (inline tree)',
+        usage: SO,
+        limits: 'Routes only under the package root routes/ directory; closures and string handlers get no target.',
+    },
+    {
+        id: 'express',
+        name: 'Express',
+        language: 'JavaScript / TypeScript',
+        markers: 'package.json depends on express',
+        relations: ['routes-to'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/express',
+        usage: SO,
+        limits: 'A router mounted under a prefix in another file (app.use) is not followed.',
+    },
+    {
+        id: 'spring',
+        name: 'Spring Boot',
+        language: 'Java',
+        markers: 'pom.xml / build.gradle names spring-boot',
+        relations: ['routes-to', 'persists', 'relates', 'injects', 'renders'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/spring',
+        usage: SO,
+        limits: '@Entity(name) is not read; a method @RequestMapping without method= is skipped; a view name built at runtime or held outside the file is not followed; Kotlin is not covered.',
+    },
+    {
+        id: 'go-http',
+        name: 'Go routers (net/http, Gin, Echo, chi)',
+        language: 'Go',
+        markers: 'a go.mod',
+        relations: ['routes-to'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/go-http',
+        usage: 'Go is in the top ten languages of GitHub Octoverse; its routers are not in the web-framework survey',
+        limits: 'chi r.Route nesting, http.HandlerFunc(f) and handler variables are not followed.',
+    },
+    {
+        id: 'symfony',
+        name: 'Symfony',
+        language: 'PHP',
+        markers: 'composer.json requires symfony/framework-bundle or symfony/symfony',
+        relations: ['routes-to', 'renders', 'persists', 'migrates', 'relates', 'injects'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/symfony',
+        usage: 'Below the survey top 20; the second PHP framework on the owner stack (Decision E4)',
+        limits: 'Twig includes are not read (templates are not code files); a route with several methods is declared once.',
+    },
+    {
+        id: 'wordpress',
+        name: 'WordPress',
+        language: 'PHP',
+        markers: 'wp-config.php; composer core packages or a wordpress-plugin / -theme package type',
+        relations: ['routes-to', 'renders'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/wordpress',
+        usage: SO,
+        limits: 'Hooks are entry nodes HOOK <name> / SHORTCODE <name>; a plugin or theme with no composer.json is not detected.',
+    },
+    {
+        id: 'fastapi',
+        name: 'FastAPI',
+        language: 'Python',
+        markers: 'fastapi in pyproject.toml or requirements',
+        relations: ['routes-to', 'injects'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/fastapi',
+        usage: SO,
+        limits: 'include_router(prefix=) from another file and add_api_route are not followed.',
+    },
+    {
+        id: 'flask',
+        name: 'Flask',
+        language: 'Python',
+        markers: 'flask in pyproject.toml or requirements',
+        relations: ['routes-to', 'renders'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/flask',
+        usage: SO,
+        limits: 'add_url_rule and blueprints nested in blueprints are not followed.',
+    },
+    {
+        id: 'django',
+        name: 'Django',
+        language: 'Python',
+        markers: 'django in a manifest, or manage.py',
+        relations: ['routes-to', 'renders', 'persists', 'relates', 'migrates'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/django',
+        usage: SO,
+        limits: 'Class-based view template_name and include() of an attribute (admin.site.urls) are not followed.',
+    },
+    {
+        id: 'sqlalchemy',
+        name: 'SQLAlchemy / SQLModel',
+        language: 'Python',
+        markers: 'sqlalchemy, flask-sqlalchemy or sqlmodel',
+        relations: ['persists', 'relates'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/sqlalchemy',
+        usage: 'ORM of the Python providers above; not a web framework',
+        limits: 'Imperative Table(...), implicit Flask-SQLAlchemy names and relationship(lambda) are not drawn.',
+    },
+    {
+        id: 'react-router',
+        name: 'React Router',
+        language: 'JavaScript / TypeScript',
+        markers: 'package.json depends on react-router or react-router-dom',
+        relations: ['routes-to'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/react-router',
+        usage: SO,
+        limits: 'Nested children paths are not joined to the parent path.',
+    },
+    {
+        id: 'nextjs',
+        name: 'Next.js',
+        language: 'JavaScript / TypeScript',
+        markers: 'package.json depends on next',
+        relations: ['routes-to', 'includes'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/nextjs',
+        usage: SO,
+        limits: 'export { h as GET } re-exports are not followed.',
+    },
+    {
+        id: 'nestjs',
+        name: 'NestJS',
+        language: 'JavaScript / TypeScript',
+        markers: 'package.json depends on @nestjs/core',
+        relations: ['routes-to', 'injects'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/nestjs',
+        usage: SO,
+        limits: '@Controller({ path }), path arrays, @Inject(token) and a global prefix are not followed.',
+    },
+    {
+        id: 'angular',
+        name: 'Angular',
+        language: 'JavaScript / TypeScript',
+        markers: 'package.json depends on @angular/core',
+        relations: ['routes-to', 'renders', 'injects'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/angular',
+        usage: SO,
+        limits: 'loadChildren, child path joining and inline templates are not followed.',
+    },
+    {
+        id: 'vue-router',
+        name: 'Vue Router',
+        language: 'JavaScript / TypeScript',
+        markers: 'package.json depends on vue-router',
+        relations: ['routes-to'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/vue-router',
+        usage: SO,
+        limits: 'Named views, alias imports and child paths are not followed.',
+    },
+    {
+        id: 'nuxt',
+        name: 'Nuxt',
+        language: 'JavaScript / TypeScript',
+        markers: 'package.json depends on nuxt',
+        relations: ['routes-to'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/nuxt',
+        usage: SO,
+        limits: 'definePageMeta path overrides are not read.',
+    },
+    {
+        id: 'sveltekit',
+        name: 'SvelteKit',
+        language: 'JavaScript / TypeScript',
+        markers: 'package.json depends on @sveltejs/kit',
+        relations: ['routes-to', 'includes'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/sveltekit',
+        usage: SO,
+        limits: '+page.server.ts, layout resets and a custom routes directory are not followed.',
+    },
+    {
+        id: 'typeorm',
+        name: 'TypeORM',
+        language: 'TypeScript',
+        markers: 'package.json depends on typeorm',
+        relations: ['persists', 'relates', 'migrates'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/typeorm',
+        usage: 'ORM of the TypeScript providers above; not a web framework',
+        limits: 'Custom naming strategies, EntitySchema and string relation targets are not followed.',
+    },
+    {
+        id: 'aspnetcore',
+        name: 'ASP.NET Core',
+        language: 'C#',
+        markers: 'a *.csproj with the Web SDK or a Microsoft.AspNetCore package reference',
+        relations: ['routes-to', 'persists', 'renders', 'injects'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/aspnetcore',
+        usage: SO,
+        limits: 'MapControllerRoute tables, a view name held in a variable and primary constructors are not followed.',
+    },
+    {
+        id: 'rails',
+        name: 'Ruby on Rails',
+        language: 'Ruby',
+        markers: 'a Gemfile declaring the rails gem',
+        relations: ['routes-to', 'persists', 'relates', 'migrates', 'renders'],
+        status: 'partial',
+        fixture: 'tests/fixtures/code-graph/rails',
+        usage: SO,
+        limits: 'resource (singular), nested resources, scope/concerns, an explicit render, config/initializers/inflections and models outside app/models are not followed.',
+    },
+    ...(
+        [
+            ['kotlin', 'Kotlin', 'Kotlin'],
+            ['rust', 'Rust', 'Rust'],
+            ['c-cpp', 'C / C++', 'C / C++'],
+            ['swift', 'Swift', 'Swift'],
+            ['dart', 'Dart', 'Dart'],
+            ['sql', 'SQL schema files', 'SQL'],
+            ['react-native', 'React Native / Expo', 'JavaScript / TypeScript'],
+            ['flutter', 'Flutter', 'Dart'],
+            ['swiftui', 'SwiftUI', 'Swift'],
+            ['jetpack-compose', 'Jetpack Compose', 'Kotlin'],
+            ['blazor', 'Blazor', 'C#'],
+            ['astro', 'Astro', 'JavaScript / TypeScript'],
+            ['fastify', 'Fastify', 'JavaScript / TypeScript'],
+            ['hono', 'Hono', 'JavaScript / TypeScript'],
+            ['remix', 'Remix', 'JavaScript / TypeScript'],
+            ['drupal', 'Drupal', 'PHP'],
+            ['quarkus', 'Quarkus', 'Java'],
+            ['micronaut', 'Micronaut', 'Java'],
+            ['prisma', 'Prisma', 'Prisma schema'],
+            ['drizzle', 'Drizzle', 'TypeScript'],
+            ['infrastructure', 'Docker, Kubernetes, Terraform, CI', 'YAML / HCL'],
+        ] as const
+    ).map(
+        ([id, name, language]): CatalogRow => ({
+            id,
+            name,
+            language,
+            markers: '—',
+            relations: [],
+            status: 'planned',
+            fixture: null,
+            usage: 'coverage list in road-to-graph-providers-for-every-stack (kill register K7)',
+        }),
+    ),
+];
+
+/** The catalog row for a provider id, if any. */
+export function catalogRow(id: string): CatalogRow | undefined {
+    return CATALOG.find((r) => r.id === id);
+}

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

@@ -0,0 +1,206 @@
+/**
+ * Django: the links a Django project makes by convention.
+ *
+ *   urls.py      path("x/", views.fn) · re_path(r"^x/$", V.as_view())  route --routes-to-->  the view function or class
+ *   any view     render(request, "app/x.html")                        --renders-->   templates/ or <app>/templates/
+ *   models.py    class X(models.Model)                                --persists-->   Meta.db_table, else <app>_<x>
+ *   models.py    ForeignKey · ManyToManyField · OneToOneField          --relates-->    the model named
+ *   migrations   migrations.CreateModel(name="X")                     --migrates-->  the same table
+ *
+ * A view is resolved the way the urls file names it: a same-file or imported
+ * symbol, or `module.member` through a module the file imports. `include(...)`
+ * of a dotted string, a `(module, namespace)` tuple or an imported module is
+ * followed: an included module's routes carry every prefix chain that reaches
+ * it from a URLconf nothing includes, and appear under no other path. An
+ * inline lambda gets a route with no target. A template found in two template
+ * folders, or built at runtime, draws nothing. The app label is the model file's
+ * directory (its parent for a `models/` package) unless `Meta.app_label` says
+ * otherwise; abstract models get no table; a `"self"` relation draws no edge.
+ */
+import * as path from 'node:path';
+
+import type { CodeNode } from '../types.js';
+import { markerRoots, pythonRoots, union } from './shared/detect.js';
+import { joinRoute, templateRoots } from './shared/extractors.js';
+import { lineIndex, makeKit } from './shared/kit.js';
+import { balanced, classBases, importedModules, kwargString, resolveModule, spanText, splitArgs, stringLiteral } from './shared/python.js';
+import type { ConventionProvider } from './types.js';
+
+const RELATION = /\b(?:models\.)?(?:ForeignKey|ManyToManyField|OneToOneField)\s*\(/g;
+
+function appLabelOf(file: string): string {
+    const dir = path.posix.dirname(file);
+    const base = path.posix.basename(dir);
+    return base === 'models' ? path.posix.basename(path.posix.dirname(dir)) : base;
+}
+
+interface Model {
+    node: CodeNode;
+    app: string;
+    table: string | null;
+}
+
+export const djangoProvider: ConventionProvider = {
+    id: 'django',
+    markers: ['manage.py'],
+    detect: (probe) => union(pythonRoots(probe, ['django']), markerRoots(probe, 'manage.py')),
+    build: (input) => {
+        const kit = makeKit(input);
+        const inventory = new Set(kit.paths);
+        const py = kit.filesWithExt('.py');
+
+        // Routes. Every URLconf is read once; `include()` links a parent to the
+        // module it names, and each route is emitted once per prefix chain that
+        // reaches its file from a URLconf nothing includes.
+        interface UrlRoute { path: string; view: string; line: number }
+        interface UrlConf { file: string; routes: UrlRoute[]; includes: Array<{ path: string; child: string }> }
+        const confs = new Map<string, UrlConf & { resolve: (expr: string) => string | null }>();
+        const pattern = (literal: string, re: boolean): string => (re ? literal.replace(/^\^/, '').replace(/\$$/, '') : literal);
+        for (const f of py.filter((x) => path.posix.basename(x.path) === 'urls.py' || /^urlpatterns\s*[:=]/m.test(x.source))) {
+            const at = lineIndex(f.source);
+            const modules = importedModules(f.path, f.source, kit.roots, inventory);
+            const resolve = (expr: string): string | null => {
+                const parts = expr.replace(/\.as_view\s*\([\s\S]*\)$/, '').split('.');
+                if (!parts.every((p) => /^[A-Za-z_]\w*$/.test(p))) return null;
+                if (parts.length === 1) return kit.resolveName(f.path, parts[0] as string);
+                if (parts.length !== 2) return null;
+                const [head, member] = parts as [string, string];
+                const mod = modules.get(head);
+                if (mod && kit.nodeById.has(`${mod}#${member}`)) return `${mod}#${member}`;
+                const cls = kit.resolveName(f.path, head);
+                return cls ? kit.methodOf(cls, member) : null;
+            };
+            /** The module an `include(...)` argument names: `"a.urls"`, `("a.urls", "ns")`, or an imported module. */
+            const includeTarget = (view: string): string | null => {
+                const open = view.indexOf('(');
+                let first = splitArgs(balanced(view, open))[0] ?? '';
+                if (first.startsWith('(') || first.startsWith('[')) first = splitArgs(balanced(first, 0))[0] ?? '';
+                const dotted = stringLiteral(first);
+                if (dotted !== null) return resolveModule(f.path, dotted, kit.roots, inventory);
+                return /^\w+$/.test(first) ? (modules.get(first) ?? null) : null;
+            };
+            const conf: UrlConf & { resolve: typeof resolve } = { file: f.path, routes: [], includes: [], resolve };
+            for (const m of f.source.matchAll(/\b(path|re_path)\s*\(/g)) {
+                const args = splitArgs(balanced(f.source, (m.index as number) + m[0].length - 1));
+                const literal = stringLiteral(args[0] ?? '');
+                const view = args[1];
+                if (literal === null || view === undefined) continue;
+                const routePath = pattern(literal, m[1] === 're_path');
+                if (/^include\s*\(/.test(view)) {
+                    const child = includeTarget(view);
+                    if (child) conf.includes.push({ path: routePath, child });
+                    continue;
+                }
+                conf.routes.push({ path: routePath, view, line: at(m.index as number) });
+            }
+            confs.set(f.path, conf);
+        }
+        const included = new Set([...confs.values()].flatMap((c) => c.includes.map((i) => i.child)));
+        const prefixes = new Map<string, Set<string>>();
+        const walk = (file: string, prefix: string, stack: readonly string[]): void => {
+            const conf = confs.get(file);
+            if (!conf || stack.includes(file)) return;
+            const seen = prefixes.get(file) ?? new Set<string>();
+            if (seen.has(prefix)) return;
+            seen.add(prefix);
+            prefixes.set(file, seen);
+            for (const inc of conf.includes) walk(inc.child, joinRoute(prefix, inc.path), [...stack, file]);
+        };
+        for (const file of confs.keys()) if (!included.has(file)) walk(file, '', []);
+        for (const conf of confs.values()) {
+            for (const prefix of prefixes.get(conf.file) ?? []) {
+                for (const r of conf.routes) {
+                    const id = kit.route(conf.file, 'ANY', joinRoute(prefix, r.path), r.line);
+                    const target = conf.resolve(r.view);
+                    if (target) kit.emit(id, target, 'routes-to', 'route-table');
+                }
+            }
+        }
+
+        // Templates: the project-level folder and every app's own.
+        const tplDirs = new Set<string>(['templates']);
+        for (const p of kit.paths) {
+            for (const r of kit.roots) {
+                const rel = r === '' ? p : p.startsWith(`${r}/`) ? p.slice(r.length + 1) : null;
+                const hit = rel === null ? null : /^([^/]+)\/templates\//.exec(rel);
+                if (hit) tplDirs.add(`${hit[1]}/templates`);
+            }
+        }
+        templateRoots(kit, {
+            exts: ['.py'],
+            call: /\b(?:render\(\s*\w+\s*,|render_to_string\(|get_template\()\s*(['"])(?<name>[^'"]+)\1/g,
+            roots: [...tplDirs].sort(),
+            extensions: [],
+        });
+
+        // Models.
+        const models = new Map<string, Model>();
+        const isDjangoFile = (src: string): boolean => /\bfrom\s+django\b|\bimport\s+django\b/.test(src);
+        for (let changed = true; changed; ) {
+            changed = false;
+            for (const f of py) {
+                if (!isDjangoFile(f.source)) continue;
+                for (const n of kit.nodesInFile(f.path)) {
+                    if (n.kind !== 'class' || models.has(n.id)) continue;
+                    const bases = classBases(f.source, n);
+                    const isModel = bases.some((b) => {
+                        if (/^(?:models\.)?Model$/.test(b)) return true;
+                        const r = /^\w+$/.test(b) ? kit.resolveName(f.path, b) : null;
+                        return r !== null && models.has(r);
+                    });
+                    if (!isModel) continue;
+                    const region = spanText(f.source, n);
+                    const app = /\bapp_label\s*=\s*(['"])(\w+)\1/.exec(region)?.[2] ?? appLabelOf(f.path);
+                    const abstract = /\babstract\s*=\s*True\b/.test(region);
+                    const table = abstract ? null : (/\bdb_table\s*=\s*[rbu]?(['"])([^'"]+)\1/.exec(region)?.[2] ?? `${app}_${n.label.toLowerCase()}`);
+                    models.set(n.id, { node: n, app, table });
+                    changed = true;
+                }
+            }
+        }
+        const sources = new Map(py.map((f) => [f.path, f.source] as const));
+        for (const m of models.values()) {
+            if (m.table) kit.emit(m.node.id, kit.table(m.table, m.node.source_file, m.node.source_location[0] as number), 'persists', 'schema-call');
+        }
+        const modelNamed = (app: string | null, label: string, file: string): string | null => {
+            const same = [...models.values()].filter((x) => x.node.label === label && x.node.source_file === file);
+            if (same.length === 1) return (same[0] as Model).node.id;
+            const inApp = [...models.values()].filter((x) => x.node.label === label && (app === null || x.app === app));
+            return inApp.length === 1 ? (inApp[0] as Model).node.id : null;
+        };
+        for (const m of models.values()) {
+            const src = sources.get(m.node.source_file) as string;
+            const region = spanText(src, m.node);
+            for (const r of region.matchAll(RELATION)) {
+                const first = splitArgs(balanced(region, (r.index as number) + r[0].length - 1))[0] ?? '';
+                const lit = stringLiteral(first);
+                let target: string | null = null;
+                if (lit !== null) {
+                    if (lit === 'self') continue;
+                    const dot = lit.lastIndexOf('.');
+                    target = dot >= 0 ? modelNamed(lit.slice(0, dot), lit.slice(dot + 1), m.node.source_file) : modelNamed(m.app, lit, m.node.source_file);
+                } else if (/^\w+$/.test(first)) {
+                    const resolved = kit.resolveName(m.node.source_file, first);
+                    target = resolved && models.has(resolved) ? resolved : null;
+                }
+                if (target && target !== m.node.id) kit.emit(m.node.id, target, 'relates', 'orm-relation');
+            }
+        }
+
+        // Migrations.
+        for (const f of py.filter((x) => /(^|\/)migrations\/[^/]+\.py$/.test(x.path))) {
+            const at = lineIndex(f.source);
+            const app = path.posix.basename(path.posix.dirname(path.posix.dirname(f.path)));
+            for (const c of f.source.matchAll(/\bmigrations\.CreateModel\s*\(/g)) {
+                const args = balanced(f.source, (c.index as number) + c[0].length - 1);
+                const name = kwargString(args, 'name') ?? stringLiteral(splitArgs(args)[0] ?? '');
+                if (!name) continue;
+                const explicit = /(['"])db_table\1\s*:\s*(['"])([^'"]+)\2/.exec(args)?.[3];
+                const model = [...models.values()].find((x) => x.app === app && x.node.label === name);
+                const table = explicit ?? model?.table ?? `${app}_${name.toLowerCase()}`;
+                kit.emit(f.path, kit.table(table, f.path, at(c.index as number)), 'migrates', 'schema-call');
+            }
+        }
+        return kit.result();
+    },
+};

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

@@ -0,0 +1,25 @@
+/**
+ * Express: `app.get('/x', handler)` and `router.post('/x', mw, handler)` →
+ * route --routes-to--> the handler the file names (same file or imported).
+ * A receiver must read as an app or a router, so `cache.get('/x')` is no route;
+ * an inline handler gets a route with no target. Mounting a router under a
+ * prefix in another file (`app.use('/api', router)`) is not followed.
+ */
+import { npmRoots } from './shared/detect.js';
+import { callRoutes } from './shared/extractors.js';
+import { makeKit } from './shared/kit.js';
+import type { ConventionProvider } from './types.js';
+
+export const expressProvider: ConventionProvider = {
+    id: 'express',
+    detect: (probe) => npmRoots(probe, ['express']),
+    build: (input) => {
+        const kit = makeKit(input);
+        callRoutes(kit, {
+            exts: ['.ts', '.js', '.mjs', '.cjs'],
+            call: /\b(?:app|router|server|api|\w+Router)\s*\.\s*(?<verb>get|post|put|patch|delete|options|head|all)\(\s*(['"`])(?<path>\/[^'"`]*)\2\s*,(?=(?<rest>[\s\S]{0,300}))/g,
+            verb: (m) => (m.groups?.['verb'] === 'all' ? 'ANY' : (m.groups?.['verb'] as string)),
+        });
+        return kit.result();
+    },
+};

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

@@ -0,0 +1,49 @@
+/**
+ * FastAPI: `@app.get("/x")` / `@router.post("/x")` → route --routes-to--> the
+ * decorated function, where the receiver is a `FastAPI(...)` or `APIRouter(...)`
+ * instance assigned in the same file (so `@cache.get("/x")` is no route). An
+ * `APIRouter(prefix="/api")` prefix applies to that router's routes.
+ *
+ * `Depends(fn)` in a parameter default → the function --injects--> fn, resolved
+ * the way the file names it (same file, then imports); `Depends(lambda: …)` and
+ * a bare `Depends()` get no edge.
+ *
+ * Not followed: `app.include_router(router, prefix=...)` mounting a router from
+ * another file, and routes registered by `app.add_api_route(...)`.
+ */
+import { pythonRoots } from './shared/detect.js';
+import { joinRoute } from './shared/extractors.js';
+import { makeKit } from './shared/kit.js';
+import { assignedCalls, kwargString, paramsOf, routeDecorators } from './shared/python.js';
+import type { ConventionProvider } from './types.js';
+
+const VERBS = ['get', 'post', 'put', 'patch', 'delete', 'options', 'head', 'api_route', 'websocket'] as const;
+
+export const fastapiProvider: ConventionProvider = {
+    id: 'fastapi',
+    detect: (probe) => pythonRoots(probe, ['fastapi']),
+    build: (input) => {
+        const kit = makeKit(input);
+        for (const f of kit.filesWithExt('.py')) {
+            const instances = assignedCalls(f.source, ['FastAPI', 'APIRouter']);
+            if (instances.size > 0) {
+                for (const d of routeDecorators(kit, f, VERBS)) {
+                    const inst = instances.get(d.receiver);
+                    if (!inst || d.path === null) continue;
+                    const verb = d.method === 'api_route' ? 'ANY' : d.method === 'websocket' ? 'WS' : d.method.toUpperCase();
+                    const id = kit.route(f.path, verb, joinRoute(kwargString(inst.args, 'prefix'), d.path), d.line);
+                    if (d.handler) kit.emit(id, d.handler.id, 'routes-to', 'route-table');
+                }
+            }
+            if (!f.source.includes('Depends(')) continue;
+            for (const n of kit.nodesInFile(f.path)) {
+                if (n.kind !== 'function' && n.kind !== 'method') continue;
+                for (const m of paramsOf(f.source, n).matchAll(/\bDepends\(\s*([A-Za-z_]\w*)\s*[,)]/g)) {
+                    const target = kit.resolveName(f.path, m[1] as string);
+                    if (target && target !== n.id) kit.emit(n.id, target, 'injects', 'di-binding');
+                }
+            }
+        }
+        return kit.result();
+    },
+};