@event4u/agent-config 17.2.1 → 17.4.0

package/src/scripts/code_graph/providers/shared/python.ts

@@ -0,0 +1,223 @@
+/**
+ * Python source helpers the Python providers share: balanced call arguments,
+ * the variables a constructor call is assigned to, keyword-argument literals,
+ * a def's parameter list and a class's declared bases. Text rules only — the
+ * extractor already supplies the symbols and their line spans.
+ */
+import type { CodeNode } from '../../types.js';
+import { type Kit, lineIndex } from './kit.js';
+
+/** The text inside the parentheses opened at `open` (the index of a `(`), skipping string literals. */
+export function balanced(src: string, open: number): string {
+    let depth = 0;
+    for (let i = open; i < src.length; i++) {
+        const c = src[i];
+        if (c === "'" || c === '"') {
+            const q = c;
+            for (i += 1; i < src.length && src[i] !== q && src[i] !== '\n'; i++) if (src[i] === '\\') i += 1;
+            continue;
+        }
+        if (c === '#') {
+            while (i < src.length && src[i] !== '\n') i += 1;
+            continue;
+        }
+        if (c === '(' || c === '[' || c === '{') depth += 1;
+        else if (c === ')' || c === ']' || c === '}') {
+            depth -= 1;
+            if (depth === 0) return src.slice(open + 1, i);
+        }
+    }
+    return src.slice(open + 1);
+}
+
+export interface AssignedCall {
+    /** The call's argument text. */
+    args: string;
+    index: number;
+}
+
+/** Module-level `name = Ctor(...)` / `name = mod.Ctor(...)` for one of `ctors`, by variable name. */
+export function assignedCalls(src: string, ctors: readonly string[]): Map<string, AssignedCall> {
+    const out = new Map<string, AssignedCall>();
+    const re = new RegExp(`^(\\w+)\\s*(?::\\s*[\\w.]+\\s*)?=\\s*(?:[\\w.]+\\.)?(?:${ctors.join('|')})\\s*\\(`, 'gm');
+    for (const m of src.matchAll(re)) {
+        const open = (m.index as number) + m[0].length - 1;
+        out.set(m[1] as string, { args: balanced(src, open), index: m.index as number });
+    }
+    return out;
+}
+
+/** The string literal a keyword argument is given (`prefix="/api"`), if it is one. */
+export function kwargString(args: string, key: string): string | undefined {
+    return new RegExp(`(?:^|[,(\\s])${key}\\s*=\\s*[rbuf]?(['"])([^'"]*)\\1`).exec(args)?.[2];
+}
+
+/** Offset of the first character of 1-based `line`. */
+export function lineOffset(src: string, line: number): number {
+    let off = 0;
+    for (let l = 1; l < line; l++) {
+        const nl = src.indexOf('\n', off);
+        if (nl < 0) return src.length;
+        off = nl + 1;
+    }
+    return off;
+}
+
+/** The parameter list text of the def a function or method node starts at. */
+export function paramsOf(src: string, fn: CodeNode): string {
+    const from = lineOffset(src, fn.source_location[0] as number);
+    const def = /\bdef\s+\w+\s*\(/g;
+    def.lastIndex = from;
+    const m = def.exec(src);
+    if (!m) return '';
+    return balanced(src, (m.index as number) + m[0].length - 1);
+}
+
+/** The source lines of a node's span, joined. */
+export function spanText(src: string, n: CodeNode): string {
+    const lines = src.split('\n');
+    const start = n.source_location[0] as number;
+    const end = (n.source_location[2] ?? start) as number;
+    return lines.slice(start - 1, end).join('\n');
+}
+
+/** The base-class expressions a class statement declares (`class A(models.Model, Mixin):` → `['models.Model', 'Mixin']`). */
+export function classBases(src: string, cls: CodeNode): string[] {
+    const head = /^\s*class\s+\w+\s*\(/.exec(spanText(src, cls));
+    if (!head) return [];
+    const text = spanText(src, cls);
+    return balanced(text, head[0].length - 1)
+        .split(',')
+        .map((b) => b.trim())
+        .filter((b) => b.length > 0 && !b.includes('='));
+}
+
+export interface RouteDecorator {
+    /** The decorated object (`app` in `@app.get(...)`). */
+    receiver: string;
+    /** The decorator attribute (`get`, `route`). */
+    method: string;
+    /** The route path: the first positional string literal, else a `path=` literal. */
+    path: string | null;
+    /** The decorator's argument text. */
+    args: string;
+    line: number;
+    /** The function or method the decorator decorates. */
+    handler: CodeNode | null;
+}
+
+/** Every `@<receiver>.<method>(...)` decorator in `file` whose method is one of `methods`. */
+export function routeDecorators(kit: Kit, file: { path: string; source: string }, methods: readonly string[]): RouteDecorator[] {
+    const at = lineIndex(file.source);
+    const out: RouteDecorator[] = [];
+    const re = new RegExp(`^[ \\t]*@(\\w+)\\.(${methods.join('|')})\\s*\\(`, 'gm');
+    for (const m of file.source.matchAll(re)) {
+        const line = at(m.index as number);
+        const args = balanced(file.source, (m.index as number) + m[0].length - 1);
+        const positional = /^\s*[rbuf]?(['"])([^'"]*)\1/.exec(args)?.[2];
+        const handler = kit.nextSymbol(file.path, line, ['function', 'method']);
+        out.push({
+            receiver: m[1] as string,
+            method: m[2] as string,
+            path: positional ?? kwargString(args, 'path') ?? null,
+            args,
+            line,
+            handler: handler && handler.kind !== 'class' ? handler : null,
+        });
+    }
+    return out;
+}
+
+/** A call's argument text split at its top-level commas, each trimmed. */
+export function splitArgs(args: string): string[] {
+    const out: string[] = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < args.length; i++) {
+        const c = args[i];
+        if (c === "'" || c === '"') {
+            const q = c;
+            for (i += 1; i < args.length && args[i] !== q; i++) if (args[i] === '\\') i += 1;
+            continue;
+        }
+        if (c === '(' || c === '[' || c === '{') depth += 1;
+        else if (c === ')' || c === ']' || c === '}') depth -= 1;
+        else if (c === ',' && depth === 0) {
+            out.push(args.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    const last = args.slice(start).trim();
+    if (last) out.push(last);
+    return out;
+}
+
+/** A string literal argument's value (`"x"`, `r"^x$"`), or null when the argument is no plain literal. */
+export function stringLiteral(arg: string): string | null {
+    return /^[rbu]?(['"])([^'"]*)\1$/.exec(arg.trim())?.[2] ?? null;
+}
+
+/**
+ * The module file a dotted import names (`a.b` → `a/b.py` or `a/b/__init__.py`),
+ * searched under each root and, for a relative import, beside `file`.
+ */
+export function resolveModule(file: string, dotted: string, roots: readonly string[], inventory: ReadonlySet<string>): string | null {
+    const dir = file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : '';
+    const rel = /^\.+/.exec(dotted)?.[0].length ?? 0;
+    const parts = dotted.slice(rel).split('.').filter(Boolean);
+    let bases: string[];
+    if (rel > 0) {
+        const segs = dir ? dir.split('/') : [];
+        bases = [segs.slice(0, Math.max(0, segs.length - (rel - 1))).join('/')];
+    } else bases = [...roots];
+    for (const b of bases) {
+        const stem = [b, ...parts].filter(Boolean).join('/');
+        // `from . import x` names the package itself: its `__init__.py`.
+        const candidates = parts.length > 0 ? [`${stem}.py`, `${stem}/__init__.py`] : rel > 0 ? [stem ? `${stem}/__init__.py` : '__init__.py'] : [];
+        for (const c of candidates) if (inventory.has(c)) return c;
+    }
+    return null;
+}
+
+/** Every `from m import a, b as c` item, as the module text, the imported name and the local name. */
+function fromImports(src: string): Array<{ mod: string; name: string; local: string }> {
+    const out: Array<{ mod: string; name: string; local: string }> = [];
+    for (const m of src.matchAll(/^\s*from\s+([.\w]+)\s+import\s+\(?([^)\n]+)\)?/gm)) {
+        for (const item of (m[2] as string).split(',')) {
+            const [name, alias] = item.trim().split(/\s+as\s+/) as [string, string | undefined];
+            if (/^\w+$/.test(name)) out.push({ mod: m[1] as string, name, local: alias ?? name });
+        }
+    }
+    return out;
+}
+
+/**
+ * Module files the file imports by name, by local name: `from a import b` and
+ * `import a.b as b` map `b` to `a/b.py` (or `a/b/__init__.py`) when that file is in
+ * `inventory`, searched under each root and, for a relative import, beside `file`.
+ */
+export function importedModules(file: string, src: string, roots: readonly string[], inventory: ReadonlySet<string>): Map<string, string> {
+    const out = new Map<string, string>();
+    for (const { mod, name, local } of fromImports(src)) {
+        const hit = resolveModule(file, mod.endsWith('.') ? `${mod}${name}` : `${mod}.${name}`, roots, inventory);
+        if (hit) out.set(local, hit);
+    }
+    for (const m of src.matchAll(/^\s*import\s+([\w.]+)\s+as\s+(\w+)\s*$/gm)) {
+        const hit = resolveModule(file, m[1] as string, roots, inventory);
+        if (hit) out.set(m[2] as string, hit);
+    }
+    return out;
+}
+
+/**
+ * Names the file imports out of a module it can resolve, by local name:
+ * `from app.main import bp as main_bp` maps `main_bp` to `{ file: 'app/main/__init__.py', name: 'bp' }`.
+ */
+export function importedNames(file: string, src: string, roots: readonly string[], inventory: ReadonlySet<string>): Map<string, { file: string; name: string }> {
+    const out = new Map<string, { file: string; name: string }>();
+    for (const { mod, name, local } of fromImports(src)) {
+        const hit = resolveModule(file, mod, roots, inventory);
+        if (hit) out.set(local, { file: hit, name });
+    }
+    return out;
+}

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

@@ -0,0 +1,175 @@
+/**
+ * Spring Boot: the links a Spring application makes by annotation.
+ *
+ *   @GetMapping("/x") · @RequestMapping(value = "/x", method = RequestMethod.GET)
+ *       under a class-level @RequestMapping("/api")     route --routes-to--> the method
+ *   @Entity class, @Table(name = "t") or the default      class --persists--> table:t
+ *   interface R extends JpaRepository<E, Id>              R     --relates-->  E
+ *   @Autowired field · constructor parameter              class --injects-->  the in-repo type
+ *   @Controller method `return "a/b"` · ModelAndView("a/b")
+ *       · a same-file `static final String` constant         method --renders--> templates/a/b.html
+ *
+ * The Java extractor spans a method or class from its first annotation, so a
+ * mapping annotation belongs to the method whose span holds it; one outside
+ * every method span (on the class) is never a route. With no table named, the
+ * table is Spring Boot's default physical name: the entity class in snake_case
+ * (`OrderLine` → `order_line`); `@Entity(name = "X")` is not read. A method-level
+ * `@RequestMapping` without `method =` and a constructor of a class carrying no
+ * stereotype annotation are not followed. A view name is read only in a
+ * `@Controller` file — a `@RestController` returns response bodies — and never
+ * from a `redirect:` / `forward:`; it renders the one template of that name
+ * under the Thymeleaf, FreeMarker, Mustache or JSP folders, or nothing.
+ */
+import { jvmRoots } from './shared/detect.js';
+import { joinRoute, tableMapping } from './shared/extractors.js';
+import { escapeRe, type Kit, lineIndex, makeKit, packageSymbol } from './shared/kit.js';
+import type { ConventionProvider } from './types.js';
+
+const VERB_MAPPING = /@(?<verb>Get|Post|Put|Delete|Patch)Mapping\b(?:\s*\(\s*(?:(?:value|path)\s*=\s*)?(?:\{\s*)?"(?<path>[^"]*)")?/g;
+const REQUEST_MAPPING = /@RequestMapping\s*\((?<args>[^)]*)\)/g;
+const STEREOTYPE = /@(?:Component|Service|Repository|Controller|RestController|Configuration)\b/;
+const AUTOWIRED_FIELD = /@Autowired\s+(?:(?:private|protected|public|final|static|transient)\s+)*(?<type>[A-Z]\w*)(?:<[^>;]*>)?\s+\w+\s*[;=]/g;
+const REPOSITORY =
+    /\binterface\s+(?<repo>\w+)\s+extends\s+(?:[\w.]+\.)?(?:JpaRepository|CrudRepository|ListCrudRepository|PagingAndSortingRepository|ReactiveCrudRepository|MongoRepository)\s*<\s*(?<entity>[A-Z]\w*)/g;
+
+function snakeCase(name: string): string {
+    return name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/([A-Z])([A-Z][a-z])/g, '$1_$2').toLowerCase();
+}
+
+/** An in-repo class or interface named `name` as `file` sees it: same file, an import, or the same package. */
+function resolveType(kit: Kit, file: string, name: string): string | null {
+    const id = kit.resolveName(file, name);
+    const n = id ? kit.nodeById.get(id) : undefined;
+    if (n && (n.kind === 'class' || n.kind === 'interface')) return n.id;
+    return packageSymbol(kit, file, name, ['class', 'interface']);
+}
+
+/** The method whose span holds `line`, or null — never the file. */
+function methodAt(kit: Kit, file: string, line: number) {
+    const id = kit.enclosing(file, line);
+    const n = kit.nodeById.get(id);
+    return n && n.kind === 'method' ? n : null;
+}
+
+function routes(kit: Kit): void {
+    for (const f of kit.filesWithExt('.java')) {
+        const at = lineIndex(f.source);
+        const lines = f.source.split('\n');
+        const hits: Array<{ line: number; verb: string; path: string | undefined }> = [];
+        const prefixes: Array<{ line: number; path: string }> = [];
+        for (const m of f.source.matchAll(VERB_MAPPING)) {
+            hits.push({ line: at(m.index as number), verb: m.groups?.['verb'] as string, path: m.groups?.['path'] });
+        }
+        for (const m of f.source.matchAll(REQUEST_MAPPING)) {
+            const args = m.groups?.['args'] ?? '';
+            const line = at(m.index as number);
+            const p = /^\s*(?:(?:value|path)\s*=\s*)?(?:\{\s*)?"(?<path>[^"]*)"/.exec(args)?.groups?.['path']
+                ?? /\b(?:value|path)\s*=\s*(?:\{\s*)?"(?<path>[^"]*)"/.exec(args)?.groups?.['path'];
+            const verb = /\bmethod\s*=\s*(?:\{\s*)?RequestMethod\.(?<verb>[A-Z]+)/.exec(args)?.groups?.['verb'];
+            if (methodAt(kit, f.path, line)) {
+                if (verb) hits.push({ line, verb, path: p });
+            } else if (p !== undefined) prefixes.push({ line, path: p });
+        }
+        for (const hit of hits) {
+            const handler = methodAt(kit, f.path, hit.line);
+            if (!handler) continue;
+            const cls = kit.classAt(f.path, handler.source_location[0] as number);
+            let prefix: string | undefined;
+            if (cls) {
+                const start = cls.source_location[0] as number;
+                const decl = lines.findIndex((l, i) => i >= start - 1 && new RegExp(`\\bclass\\s+${cls.label}\\b`).test(l)) + 1;
+                prefix = prefixes.filter((p) => p.line >= start && p.line <= decl).pop()?.path;
+            }
+            const id = kit.route(f.path, hit.verb.toUpperCase(), joinRoute(prefix, hit.path), hit.line);
+            kit.emit(id, handler.id, 'routes-to', 'route-table');
+        }
+    }
+}
+
+function repositories(kit: Kit): void {
+    for (const f of kit.filesWithExt('.java')) {
+        for (const m of f.source.matchAll(REPOSITORY)) {
+            const repo = resolveType(kit, f.path, m.groups?.['repo'] as string);
+            const entity = resolveType(kit, f.path, m.groups?.['entity'] as string);
+            if (repo && entity) kit.emit(repo, entity, 'relates', 'orm-relation');
+        }
+    }
+}
+
+function injections(kit: Kit): void {
+    for (const f of kit.filesWithExt('.java')) {
+        const at = lineIndex(f.source);
+        const lines = f.source.split('\n');
+        for (const m of f.source.matchAll(AUTOWIRED_FIELD)) {
+            const cls = kit.classAt(f.path, at(m.index as number));
+            const target = resolveType(kit, f.path, m.groups?.['type'] as string);
+            if (cls && target && target !== cls.id) kit.emit(cls.id, target, 'injects', 'di-binding');
+        }
+        for (const n of kit.nodesInFile(f.path)) {
+            if (n.kind !== 'class') continue;
+            const ctorId = kit.methodOf(n.id, n.label);
+            const ctor = ctorId ? kit.nodeById.get(ctorId) : undefined;
+            if (!ctor) continue;
+            const start = n.source_location[0] as number;
+            const head = lines.slice(start - 1, (ctor.source_location[0] as number) - 1).join('\n');
+            const ctorText = lines.slice((ctor.source_location[0] as number) - 1, ctor.source_location[2] as number).join('\n');
+            if (!STEREOTYPE.test(head.split(new RegExp(`\\bclass\\s+${escapeRe(n.label)}\\b`))[0] ?? '') && !/@Autowired\b/.test(ctorText)) continue;
+            const params = new RegExp(`\\b${escapeRe(n.label)}\\s*\\((?<params>[^)]*)\\)`).exec(ctorText)?.groups?.['params'] ?? '';
+            for (const param of params.split(',')) {
+                const type = /(?:^|\s)(?<type>[A-Z]\w*)(?:<[^>]*>)?\s+\w+\s*$/.exec(param.replace(/@\w+(?:\([^)]*\))?/g, '').trim())?.groups?.['type'];
+                const target = type ? resolveType(kit, f.path, type) : null;
+                if (target && target !== n.id) kit.emit(n.id, target, 'injects', 'di-binding');
+            }
+        }
+    }
+}
+
+const VIEW_ROOTS = ['src/main/resources/templates', 'src/main/webapp/WEB-INF/views', 'src/main/webapp/WEB-INF/jsp'];
+const VIEW_EXTS = ['.html', '.ftlh', '.ftl', '.mustache', '.jte', '.jsp'];
+const VIEW_NAME = /\b(?:return\s+|new\s+ModelAndView\s*\(\s*)(?:"(?<lit>[^"]*)"|(?<const>[A-Z][A-Z0-9_]*))\s*[;),]/g;
+const VIEW_CONSTANT = /\bstatic\s+final\s+String\s+(?<name>[A-Z][A-Z0-9_]*)\s*=\s*"(?<value>[^"]*)"/g;
+
+function views(kit: Kit): void {
+    const inventory = new Set(kit.paths);
+    for (const f of kit.filesWithExt('.java')) {
+        if (!/@Controller\b/.test(f.source)) continue;
+        const at = lineIndex(f.source);
+        const constants = new Map([...f.source.matchAll(VIEW_CONSTANT)].map((m) => [m.groups?.['name'] as string, m.groups?.['value'] as string]));
+        for (const m of f.source.matchAll(VIEW_NAME)) {
+            const name = m.groups?.['lit'] ?? constants.get(m.groups?.['const'] ?? '');
+            if (!name || /^(?:redirect|forward):/.test(name)) continue;
+            const method = methodAt(kit, f.path, at(m.index as number));
+            if (!method) continue;
+            const hits = new Set<string>();
+            for (const r of kit.roots)
+                for (const dir of VIEW_ROOTS)
+                    for (const ext of VIEW_EXTS) {
+                        const c = [r, dir, `${name.replace(/^\/+/, '')}${ext}`].filter(Boolean).join('/');
+                        if (inventory.has(c)) hits.add(c);
+                    }
+            if (hits.size !== 1) continue;
+            const target = [...hits][0] as string;
+            kit.fileNode(target);
+            kit.emit(method.id, target, 'renders', 'directive-scan');
+        }
+    }
+}
+
+export const springProvider: ConventionProvider = {
+    id: 'spring',
+    detect: (probe) => jvmRoots(probe, /spring-boot|org\.springframework\.boot/),
+    build: (input) => {
+        const kit = makeKit(input);
+        routes(kit);
+        tableMapping(kit, {
+            exts: ['.java'],
+            entity: /@Entity\b/g,
+            tableName: /@Table\s*\(\s*(?:name\s*=\s*)?"(?<name>[^"]+)"/,
+            convention: snakeCase,
+        });
+        repositories(kit);
+        injections(kit);
+        views(kit);
+        return kit.result();
+    },
+};

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

@@ -0,0 +1,62 @@
+/**
+ * SQLAlchemy (and Flask-SQLAlchemy, SQLModel): a declarative class with
+ * `__tablename__ = "x"` --persists--> `table:x`; a SQLModel class declared with
+ * `table=True` and no `__tablename__` gets SQLModel's default, its lowercased
+ * class name. `relationship("Other")` / `relationship(Other)` inside a mapped
+ * class --relates--> the mapped class named: a string resolves to the one mapped
+ * class of that name in the project, a bare name the way the file imports it.
+ *
+ * Not drawn: imperative `Table("x", metadata, ...)` mappings, Flask-SQLAlchemy's
+ * implicit table names (a `db.Model` without `__tablename__`), a
+ * `relationship(lambda: X)` or a target named only in a `Mapped[...]` annotation,
+ * and SQLModel's `Relationship(...)`.
+ */
+import type { CodeNode } from '../types.js';
+import { pythonRoots } from './shared/detect.js';
+import { lineIndex, makeKit } from './shared/kit.js';
+import { balanced, spanText, splitArgs, stringLiteral } from './shared/python.js';
+import type { ConventionProvider } from './types.js';
+
+export const sqlalchemyProvider: ConventionProvider = {
+    id: 'sqlalchemy',
+    detect: (probe) => pythonRoots(probe, ['sqlalchemy', 'flask-sqlalchemy', 'sqlmodel']),
+    build: (input) => {
+        const kit = makeKit(input);
+        const mapped = new Map<string, { node: CodeNode; source: string }>();
+        for (const f of kit.filesWithExt('.py')) {
+            const at = lineIndex(f.source);
+            for (const m of f.source.matchAll(/^[ \t]+__tablename__\s*(?::[^=\n]+)?=\s*(['"])(\w+)\1/gm)) {
+                const cls = kit.classAt(f.path, at(m.index as number));
+                if (!cls || mapped.has(cls.id)) continue;
+                mapped.set(cls.id, { node: cls, source: f.source });
+                kit.emit(cls.id, kit.table(m[2] as string, f.path, cls.source_location[0] as number), 'persists', 'schema-call');
+            }
+            for (const n of kit.nodesInFile(f.path)) {
+                if (n.kind !== 'class' || mapped.has(n.id)) continue;
+                const head = /^\s*class\s+\w+\s*\(([^)]*)\)/.exec(spanText(f.source, n))?.[1] ?? '';
+                if (!/\btable\s*=\s*True\b/.test(head)) continue;
+                mapped.set(n.id, { node: n, source: f.source });
+                kit.emit(n.id, kit.table(n.label.toLowerCase(), f.path, n.source_location[0] as number), 'persists', 'schema-call');
+            }
+        }
+        const byLabel = (label: string): string | null => {
+            const hits = [...mapped.values()].filter((x) => x.node.label === label);
+            return hits.length === 1 ? (hits[0]?.node.id ?? null) : null;
+        };
+        for (const { node, source } of mapped.values()) {
+            const region = spanText(source, node);
+            for (const r of region.matchAll(/\brelationship\s*\(/g)) {
+                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) target = byLabel(lit.slice(lit.lastIndexOf('.') + 1));
+                else if (/^\w+$/.test(first)) {
+                    const resolved = kit.resolveName(node.source_file, first);
+                    target = resolved && mapped.has(resolved) ? resolved : null;
+                }
+                if (target && target !== node.id) kit.emit(node.id, target, 'relates', 'orm-relation');
+            }
+        }
+        return kit.result();
+    },
+};

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

@@ -0,0 +1,59 @@
+/**
+ * SvelteKit file routing under `src/routes/` of a package root:
+ *
+ *   +page.svelte · +page.ts     PAGE /a/[slug]           --routes-to--> that module
+ *   +server.ts                  GET /api/x · POST …      --routes-to--> the exported verb function
+ *   +layout.svelte              --includes-->             every +page.svelte below its directory
+ *
+ * Route groups drop out of the path; route ids match the default pass's, so a
+ * page drawn here replaces the generic one. `+page.server.ts` load functions,
+ * `+layout@group` resets and a custom `kit.files.routes` directory are not
+ * followed; the default pass still adds its generic `ROUTE` node for a
+ * `+server.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 = /^\+page\.(svelte|ts|js)$/;
+const SERVER = /^\+server\.(ts|js)$/;
+const LAYOUT = /^\+layout\.svelte$/;
+
+export const sveltekitProvider: ConventionProvider = {
+    id: 'sveltekit',
+    detect: (probe) => npmRoots(probe, ['@sveltejs/kit']),
+    build: (input) => {
+        const kit = makeKit(input);
+        const pages: string[] = [];
+        const layouts: string[] = [];
+        for (const p of kit.paths) {
+            const at = underRoot(kit.roots, p);
+            if (!at) continue;
+            const segs = at.rel.split('/');
+            if (segs[0] !== 'src' || segs[1] !== 'routes') continue;
+            const base = segs[segs.length - 1] as string;
+            const route = cleanRoute(segs.slice(2, -1));
+            if (PAGE.test(base)) {
+                kit.fileNode(p);
+                kit.emit(kit.route(p, 'PAGE', route, 1), p, 'routes-to', 'route-table');
+                if (base.endsWith('.svelte')) pages.push(p);
+            } else if (SERVER.test(base)) {
+                if (kit.fileIds.has(p)) exportedVerbRoutes(kit, p, route);
+            } else if (LAYOUT.test(base)) {
+                layouts.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/symfony.ts

@@ -0,0 +1,142 @@
+/**
+ * Symfony: the links a Symfony application makes by attribute or convention.
+ *
+ *   #[Route('/x', methods: ['GET'])] · @Route("/x")   route --routes-to--> the method below it,
+ *                                                       under the class-level `#[Route('/prefix')]`
+ *   $this->render('a/b.html.twig')                     method --renders--> templates/a/b.html.twig
+ *   #[ORM\Entity] (+ #[ORM\Table(name: 't')])          entity --persists--> table:t (default: snake_case short name)
+ *   #[ORM\ManyToOne(targetEntity: X::class)] …          entity --relates--> X (else the property's type)
+ *   migrations/*.php  $this->addSql('CREATE TABLE t')   migration --migrates--> table:t
+ *   __construct(private Mailer $m)                     class --injects--> Mailer (an in-repo class only)
+ *
+ * Class references resolve through the file's `use` aliases and the PSR-4
+ * map, so a same-named class in another namespace is never the target. A route
+ * with several `methods` is declared once, under the first. Twig's own
+ * `{% include %}` / `{% extends %}` are not followed: a provider reads only
+ * code files, and `.twig` is not one.
+ */
+import * as path from 'node:path';
+
+import type { FileRole } from '../map_model.js';
+import { composerRoots } from './shared/detect.js';
+import { annotationRoutes, tableMapping, templateRoots } from './shared/extractors.js';
+import { type Kit, lineIndex, makeKit } from './shared/kit.js';
+import { classNode, matchingClose, phpScope, qualify } from './shared/php.js';
+import type { ConventionProvider } from './types.js';
+import type { ResolutionConfig } from '../resolution_tiers.js';
+
+/** Arguments of an attribute or annotation, one level of nested brackets deep. */
+const ARGS = String.raw`(?<args>(?:[^()\[\]{}]|\[[^\]]*\]|\{[^}]*\})*)`;
+/** The next declaration after the match is a method, not a class (`Post::class` is no declaration). */
+const BEFORE = (decl: string): string =>
+    String.raw`(?=(?:(?!(?<!::)\bclass\s+[A-Za-z_]|\bfunction\b)[\s\S]){0,800}${decl})`;
+const ROUTE_HEAD = String.raw`(?:#\[|@)Route\(\s*(?:path\s*[:=]\s*)?(['"])(?<path>[^'"]*)\1${ARGS}\)`;
+const METHOD_ROUTE = new RegExp(ROUTE_HEAD + BEFORE(String.raw`\bfunction\b`), 'g');
+const CLASS_ROUTE = new RegExp(ROUTE_HEAD + BEFORE(String.raw`(?<!::)\bclass\s+[A-Za-z_]`), 'g');
+
+const RELATION = /(?:#\[|@)ORM\\(?:ManyToOne|OneToMany|ManyToMany|OneToOne)\b(?<args>\((?:[^()]|\([^()]*\))*\))?/g;
+const TARGET_ENTITY = /targetEntity\s*[:=]\s*(?:(?<cls>[\\\w]+)::class|(['"])(?<str>[\\\w]+)\2)/;
+const PROPERTY = /(?:public|protected|private|var)\s+(?:readonly\s+)?(?:(?<type>\??[\\\w]+)\s+)?\$\w+/;
+
+const snake = (name: string): string => name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+
+function verbOf(m: RegExpMatchArray): string {
+    const args = m.groups?.['args'] ?? '';
+    return /methods\s*[:=]\s*[[{]\s*['"](\w+)['"]/.exec(args)?.[1] ?? 'ANY';
+}
+
+function relations(kit: Kit, resolution: ResolutionConfig): void {
+    for (const f of kit.filesWithExt('.php')) {
+        const at = lineIndex(f.source);
+        const scope = phpScope(f.source);
+        for (const m of f.source.matchAll(RELATION)) {
+            const line = at(m.index as number);
+            const cls = kit.classAt(f.path, line);
+            if (!cls) continue;
+            const t = TARGET_ENTITY.exec(m.groups?.['args'] ?? '');
+            let fq: string | null = null;
+            if (t?.groups?.['cls']) fq = qualify(t.groups['cls'], scope);
+            else if (t?.groups?.['str']) {
+                const s = t.groups['str'];
+                fq = s.includes('\\') ? s.replace(/^\\/, '') : qualify(s, { namespace: scope.namespace, uses: new Map() });
+            } else {
+                const type = PROPERTY.exec(f.source.slice((m.index as number) + m[0].length))?.groups?.['type'];
+                if (type) fq = qualify(type.replace(/^\?/, ''), scope);
+            }
+            const target = fq ? classNode(kit, fq, resolution) : null;
+            if (target && target !== cls.id) kit.emit(cls.id, target, 'relates', 'orm-relation');
+        }
+    }
+}
+
+/** Top-level comma split of a parameter list. */
+function params(list: string): string[] {
+    const out: string[] = [];
+    let depth = 0;
+    let cur = '';
+    for (const ch of list) {
+        if (ch === '(' || ch === '[' || ch === '{') depth += 1;
+        else if (ch === ')' || ch === ']' || ch === '}') depth -= 1;
+        if (ch === ',' && depth === 0) {
+            out.push(cur);
+            cur = '';
+        } else cur += ch;
+    }
+    out.push(cur);
+    return out;
+}
+
+function injections(kit: Kit, resolution: ResolutionConfig): void {
+    for (const f of kit.filesWithExt('.php')) {
+        const at = lineIndex(f.source);
+        const scope = phpScope(f.source);
+        for (const m of f.source.matchAll(/\bfunction\s+__construct\s*\(/g)) {
+            const open = (m.index as number) + m[0].length - 1;
+            const cls = kit.classAt(f.path, at(m.index as number));
+            if (!cls) continue;
+            for (const p of params(f.source.slice(open + 1, matchingClose(f.source, open)))) {
+                const type = /^\s*(?:#\[[^\]]*\]\s*)*(?:(?:public|protected|private|readonly)\s+)*(?<type>\??[\\\w|]+)\s+&?(?:\.\.\.)?\$\w+/.exec(p)?.groups?.['type'];
+                for (const ref of (type ?? '').replace(/^\?/, '').split('|').filter(Boolean)) {
+                    const target = classNode(kit, qualify(ref, scope), resolution);
+                    if (target && target !== cls.id) kit.emit(cls.id, target, 'injects', 'di-binding');
+                }
+            }
+        }
+    }
+}
+
+function symfonyRole(p: string): FileRole | undefined {
+    if (p.startsWith('templates/')) return 'view';
+    if (p === 'public/index.php' || p === 'bin/console') return 'entry';
+    if (p.startsWith('migrations/')) return 'migration';
+    return undefined;
+}
+
+export const symfonyProvider: ConventionProvider = {
+    id: 'symfony',
+    detect: (probe) => composerRoots(probe, ['symfony/framework-bundle', 'symfony/symfony']),
+    build: (input) => {
+        const kit = makeKit(input);
+        annotationRoutes(kit, { exts: ['.php'], route: METHOD_ROUTE, verb: verbOf, prefix: CLASS_ROUTE, prefixReach: 12 });
+        templateRoots(kit, {
+            exts: ['.php'],
+            call: /\$this->render(?:View|Block)?\(\s*(['"])(?<name>[\w./@-]+)\1/g,
+            roots: ['templates'],
+            extensions: ['.html.twig', '.twig'],
+        });
+        tableMapping(kit, {
+            exts: ['.php'],
+            entity: /(?:#\[|@)ORM\\Entity\b/g,
+            tableName: /(?:#\[|@)ORM\\Table\(\s*(?:name\s*[:=]\s*)?(['"])(?<name>\w+)\1/,
+            convention: snake,
+            migration: {
+                files: (p) => /(?:^|\/)migrations\/[^/]+\.php$/.test(p),
+                create: /addSql\(\s*(['"])\s*(?:CREATE|ALTER)\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"]?(?<name>\w+)/gi,
+            },
+        });
+        relations(kit, input.resolution);
+        injections(kit, input.resolution);
+        return kit.result();
+    },
+    roleOf: (p) => symfonyRole(path.posix.normalize(p)),
+};