@event4u/agent-config 17.2.1 → 17.3.0

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

@@ -0,0 +1,210 @@
+/**
+ * The building blocks every convention provider shares: emitting deduplicated
+ * edges, declaring route and table nodes, finding the symbol a line belongs to
+ * or the one a decorator precedes, and resolving a handler name the way the
+ * file itself states it (same file, then its imports).
+ *
+ * A provider stays a parameter table plus the semantics only it knows; the
+ * mechanics live here once (road-to-graph-providers-for-every-stack 4.1).
+ */
+import * as path from 'node:path';
+
+import type { SourceFile } from '../../build.js';
+import type { CodeEdge, CodeNode, ResolvedVia } from '../../types.js';
+import type { ProviderInput, ProviderResult } from '../types.js';
+
+/** A string matched literally inside a `RegExp` built from a symbol name. */
+export function escapeRe(s: string): string {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** Line-start offsets, so many `lineAt` lookups stay linear. */
+export function lineIndex(src: string): (index: number) => number {
+    const starts = [0];
+    for (let i = 0; i < src.length; i++) if (src.charCodeAt(i) === 10) starts.push(i + 1);
+    return (index: number): number => {
+        let lo = 0;
+        let hi = starts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if ((starts[mid] as number) <= index) lo = mid;
+            else hi = mid - 1;
+        }
+        return lo + 1;
+    };
+}
+
+export interface Kit {
+    files: readonly SourceFile[];
+    fileIds: ReadonlySet<string>;
+    nodeById: ReadonlyMap<string, CodeNode>;
+    /** Every project path under the provider's roots, code or not. */
+    paths: readonly string[];
+    /** The package roots the provider was detected in (`''` is the repository root). */
+    roots: readonly string[];
+    /** The code files whose path ends with one of `exts`. */
+    filesWithExt(...exts: string[]): SourceFile[];
+    /** Make sure a file node exists for a non-code target (a template). */
+    fileNode(p: string): void;
+    /** Every base node declared in `file` (indexed once; never a scan of the whole graph). */
+    nodesInFile(file: string): readonly CodeNode[];
+    /** Every base node with this label (indexed once). */
+    nodesNamed(label: string): readonly CodeNode[];
+    /** Whether a project path is in the inventory (indexed once). */
+    hasPath(p: string): boolean;
+    emit(source: string, target: string, relation: CodeEdge['relation'], via: ResolvedVia): void;
+    /** Declare a route node in `file`; returns its id (`<file>#route:<VERB> <path>`, `@n` when repeated). */
+    route(file: string, verb: string, routePath: string, line: number): string;
+    /** Declare (once) the table node `table:<name>`, first seen in `file`. */
+    table(name: string, file: string, line: number): string;
+    /** The innermost function or method node whose span holds `line`, else the file. */
+    enclosing(file: string, line: number): string;
+    /** The first function, method or class node starting at or after `line` (what a decorator decorates). */
+    nextSymbol(file: string, line: number, kinds?: readonly CodeNode['kind'][]): CodeNode | null;
+    /** The class node whose span holds `line`. */
+    classAt(file: string, line: number): CodeNode | null;
+    /**
+     * A name as written in `file`, resolved the way the file states it: a
+     * same-file symbol first, then a symbol an import edge of the file binds.
+     */
+    resolveName(file: string, name: string): string | null;
+    /** A method `member` of the class node `classId`, if the class declares it. */
+    methodOf(classId: string, member: string): string | null;
+    result(): ProviderResult;
+}
+
+export function makeKit(input: ProviderInput): Kit {
+    const files = input.files;
+    const fileIds = new Set(files.map((f) => f.path));
+    const nodeById = new Map(input.baseNodes.map((n) => [n.id, n] as const));
+    const nodes: CodeNode[] = [];
+    const edges: CodeEdge[] = [];
+    const seenEdge = new Set<string>();
+    const seenNode = new Set<string>();
+    const routeOrdinal = new Map<string, number>();
+    let byFile: Map<string, CodeNode[]> | null = null;
+    let byLabel: Map<string, CodeNode[]> | null = null;
+    let pathSet: Set<string> | null = null;
+    const index = (key: (n: CodeNode) => string): Map<string, CodeNode[]> => {
+        const m = new Map<string, CodeNode[]>();
+        for (const n of input.baseNodes) {
+            const k = key(n);
+            const list = m.get(k);
+            if (list) list.push(n);
+            else m.set(k, [n]);
+        }
+        return m;
+    };
+
+    const symbolsByFile = new Map<string, CodeNode[]>();
+    for (const n of input.baseNodes) {
+        if (n.kind === 'file' || n.source_location.length === 0) continue;
+        const list = symbolsByFile.get(n.source_file) ?? [];
+        list.push(n);
+        symbolsByFile.set(n.source_file, list);
+    }
+    for (const list of symbolsByFile.values()) list.sort((a, b) => (a.source_location[0] as number) - (b.source_location[0] as number));
+
+    const importsByFile = new Map<string, Map<string, string>>();
+    for (const e of input.baseEdges) {
+        if (e.relation !== 'imports') continue;
+        const from = nodeById.get(e.source)?.source_file;
+        const to = nodeById.get(e.target);
+        if (!from || !to) continue;
+        const m = importsByFile.get(from) ?? new Map<string, string>();
+        if (!m.has(to.label)) m.set(to.label, to.id);
+        importsByFile.set(from, m);
+    }
+
+    const emit: Kit['emit'] = (source, target, relation, via) => {
+        const key = `${source}\0${relation}\0${target}`;
+        if (seenEdge.has(key)) return;
+        seenEdge.add(key);
+        edges.push({ source, target, relation, confidence: 'EXTRACTED', resolved_via: via, provider: 'native' });
+    };
+    const span = (n: CodeNode): [number, number] => [n.source_location[0] as number, (n.source_location[2] ?? n.source_location[0]) as number];
+
+    return {
+        files,
+        fileIds,
+        nodeById,
+        paths: input.paths,
+        roots: input.roots,
+        nodesInFile: (file) => (byFile ??= index((n) => n.source_file)).get(file) ?? [],
+        nodesNamed: (label) => (byLabel ??= index((n) => n.label)).get(label) ?? [],
+        hasPath: (p) => (pathSet ??= new Set(input.paths)).has(p),
+        filesWithExt: (...exts) => files.filter((f) => exts.some((x) => f.path.endsWith(x))),
+        fileNode(p) {
+            if (nodeById.has(p) || seenNode.has(p)) return;
+            seenNode.add(p);
+            nodes.push({ id: p, label: p, kind: 'file', source_file: p, source_location: [] });
+        },
+        emit,
+        route(file, verb, routePath, line) {
+            const base = `${file}#route:${verb} ${routePath}`;
+            const n = (routeOrdinal.get(base) ?? 0) + 1;
+            routeOrdinal.set(base, n);
+            const id = n === 1 ? base : `${base}@${n}`;
+            nodes.push({ id, label: `${verb} ${routePath}`, kind: 'route', source_file: file, source_location: [line, 1, line, 1] });
+            emit(file, id, 'member', 'same-file');
+            return id;
+        },
+        table(name, file, line) {
+            const id = `table:${name}`;
+            if (!seenNode.has(id)) {
+                seenNode.add(id);
+                nodes.push({ id, label: name, kind: 'table', source_file: file, source_location: [line, 1, line, 1] });
+            }
+            return id;
+        },
+        enclosing(file, line) {
+            let best: CodeNode | null = null;
+            for (const n of symbolsByFile.get(file) ?? []) {
+                if (n.kind !== 'method' && n.kind !== 'function') continue;
+                const [s, e] = span(n);
+                if (s <= line && line <= e && (!best || s >= (best.source_location[0] as number))) best = n;
+            }
+            return best ? best.id : file;
+        },
+        nextSymbol(file, line, kinds = ['method', 'function', 'class']) {
+            for (const n of symbolsByFile.get(file) ?? []) if (kinds.includes(n.kind) && span(n)[0] >= line) return n;
+            return null;
+        },
+        classAt(file, line) {
+            let best: CodeNode | null = null;
+            for (const n of symbolsByFile.get(file) ?? []) {
+                if (n.kind !== 'class') continue;
+                const [s, e] = span(n);
+                if (s <= line && line <= e && (!best || s >= (best.source_location[0] as number))) best = n;
+            }
+            return best;
+        },
+        resolveName(file, name) {
+            const local = (symbolsByFile.get(file) ?? []).find((n) => n.label === name && n.kind !== 'method');
+            if (local) return local.id;
+            return importsByFile.get(file)?.get(name) ?? null;
+        },
+        methodOf(classId, member) {
+            const id = `${classId}::${member}`;
+            return nodeById.has(id) ? id : null;
+        },
+        result: () => ({ nodes, edges }),
+    };
+}
+
+/**
+ * The one symbol named `name` declared by a file in `file`'s own directory with
+ * the same extension — what a language whose package is its directory (Go, a
+ * Java package) sees without an import. Null when none or several declare it.
+ */
+export function packageSymbol(kit: Kit, file: string, name: string, kinds: readonly CodeNode['kind'][]): string | null {
+    const dir = path.posix.dirname(file);
+    const ext = path.posix.extname(file);
+    const hits: string[] = [];
+    for (const n of kit.nodesNamed(name)) {
+        if (!kinds.includes(n.kind)) continue;
+        if (path.posix.dirname(n.source_file) !== dir || path.posix.extname(n.source_file) !== ext) continue;
+        hits.push(n.id);
+    }
+    return hits.length === 1 ? (hits[0] as string) : null;
+}

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

@@ -0,0 +1,64 @@
+/**
+ * PHP name resolution shared by the PHP providers: a class reference read the
+ * way its file states it (namespace + `use` aliases), then located through the
+ * project's PSR-4 map. A reference that resolves to no class node in the graph
+ * resolves to nothing — never to a same-named class in another namespace.
+ */
+import { resolvePsr4, type ResolutionConfig } from '../../resolution_tiers.js';
+import type { Kit } from './kit.js';
+
+export interface PhpScope {
+    namespace: string;
+    uses: Map<string, string>;
+}
+
+export function phpScope(src: string): PhpScope {
+    const ns = /^\s*namespace\s+([\\\w]+)\s*;/m.exec(src)?.[1] ?? '';
+    const uses = new Map<string, string>();
+    for (const m of src.matchAll(/^\s*use\s+([\\\w]+)(?:\s+as\s+(\w+))?\s*;/gm)) {
+        const fq = (m[1] as string).replace(/^\\/, '');
+        uses.set(m[2] ?? fq.split('\\').pop() ?? fq, fq);
+    }
+    return { namespace: ns, uses };
+}
+
+/** Fully-qualified name of a class reference as written under `scope`. */
+export function qualify(ref: string, scope: PhpScope): string {
+    if (ref.startsWith('\\')) return ref.slice(1);
+    const [head, ...rest] = ref.split('\\');
+    const aliased = scope.uses.get(head as string);
+    if (aliased) return [aliased, ...rest].join('\\');
+    return scope.namespace ? `${scope.namespace}\\${ref}` : ref;
+}
+
+export function shortName(fq: string): string {
+    return fq.split('\\').pop() ?? fq;
+}
+
+/** The class node a fully-qualified name names, through PSR-4; null when absent. */
+export function classNode(kit: Kit, fq: string, resolution: ResolutionConfig): string | null {
+    const file = resolvePsr4(fq, resolution, kit.fileIds);
+    const id = file ? `${file}#${shortName(fq)}` : null;
+    return id && kit.nodeById.has(id) ? id : null;
+}
+
+/** Offset of the bracket closing the one at `open` (`(`, `[` or `{`), skipping string literals. */
+export function matchingClose(src: string, open: number): number {
+    const pair: Record<string, string> = { '(': ')', '[': ']', '{': '}' };
+    const o = src[open] as string;
+    const c = pair[o];
+    let depth = 0;
+    for (let i = open; i < src.length; i++) {
+        const ch = src[i];
+        if (ch === "'" || ch === '"') {
+            for (i += 1; i < src.length && src[i] !== ch; i++) if (src[i] === '\\') i += 1;
+            continue;
+        }
+        if (ch === o) depth += 1;
+        else if (ch === c) {
+            depth -= 1;
+            if (depth === 0) return i;
+        }
+    }
+    return src.length;
+}

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,138 @@
+/**
+ * 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
+ *
+ * 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.
+ */
+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');
+            }
+        }
+    }
+}
+
+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);
+        return kit.result();
+    },
+};