context-slice 1.8.2

package/dist/src/languages/java/enterprise/spring-data.js

@@ -0,0 +1,239 @@
+import { registerEnterpriseExtractor, registerEnterpriseResolver } from "./registry.js";
+// Two-phase like jpa-entity.ts: provisional PERSISTS_ENTITY carries the raw entity simple
+// name in targetLabel; this file's own resolver (separate from jpa-entity's, each file
+// self-contained) applies the unique-simple-name rule. REPOSITORY_QUERY is a structural
+// fact about the method itself, so it is emitted "exact" and never touched by the resolver.
+const BASE_RE = /\b(?:JpaRepository|CrudRepository|PagingAndSortingRepository|Repository)\s*</g;
+const DERIVED_RE = /^(?:find|exists|delete|count)By(?=[A-Z])/;
+/** Strips a leading "@" and any dotted package prefix, e.g. "@org.springframework...Query" -> "Query". */
+function bareName(annotation) {
+    return annotation.slice(annotation.lastIndexOf(".") + 1).replace("@", "");
+}
+/** Top-level type arguments of the `<...>` opening at `open`, or undefined if unbalanced. */
+function typeArguments(text, open) {
+    const args = [];
+    let depth = 0;
+    let start = open + 1;
+    for (let i = open; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === "<")
+            depth++;
+        else if (ch === ">" && --depth === 0) {
+            args.push(text.slice(start, i).trim());
+            return { args, end: i + 1 };
+        }
+        else if (ch === "," && depth === 1) {
+            args.push(text.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    return undefined;
+}
+/** First known base-repository supertype with exactly two plain type arguments. */
+function repositoryShape(iface) {
+    const header = iface.source.slice(0, iface.source.includes("{") ? iface.source.indexOf("{") : undefined);
+    for (const m of header.matchAll(BASE_RE)) {
+        const open = (m.index ?? 0) + m[0].length - 1;
+        const parsed = typeArguments(header, open);
+        if (!parsed || parsed.args.length !== 2)
+            continue;
+        const [entity, id] = parsed.args;
+        // A generic entity argument (Map<String, Long>) names no single project type: drop, never guess.
+        if (!/^[\w.]+$/.test(entity))
+            continue;
+        return {
+            matched: header.slice(m.index, parsed.end).replace(/\s+/g, " "),
+            entity: entity.slice(entity.lastIndexOf(".") + 1),
+            id,
+        };
+    }
+    return undefined;
+}
+/** Split only where And/Or sits between a lowercase/digit end and an uppercase start. */
+function derivedProperties(name) {
+    if (!DERIVED_RE.test(name))
+        return undefined;
+    return name
+        .replace(DERIVED_RE, "")
+        .split(/(?<=[a-z0-9])(?:And|Or)(?=[A-Z])/)
+        .filter(Boolean)
+        .map((seg) => `property: ${seg[0].toLowerCase()}${seg.slice(1)}`);
+}
+/**
+ * Verbatim @Query(...) argument text (string-literal aware); undefined if absent/unbalanced.
+ * Detection of whether @Query is present happens via SymbolRecord.annotations first -- never
+ * via the search regex below on its own, which previously matched inside comments or string
+ * literals anywhere in the method's source (a method body, not just its header, can contain
+ * arbitrary text). The qualified-name-tolerant prefix mirrors every prior phase's fix for a
+ * fully-qualified annotation name.
+ */
+function queryText(method) {
+    if (!method.annotations.some((a) => bareName(a) === "Query"))
+        return undefined;
+    const at = method.source.search(/@(?:[\w.]+\.)?Query\s*\(/);
+    if (at === -1)
+        return undefined;
+    const open = method.source.indexOf("(", at);
+    let depth = 0;
+    let inString = false;
+    for (let i = open; i < method.source.length; i++) {
+        const ch = method.source[i];
+        if (ch === '"' && method.source[i - 1] !== "\\")
+            inString = !inString;
+        if (inString)
+            continue;
+        if (ch === "(")
+            depth++;
+        else if (ch === ")" && --depth === 0)
+            return method.source.slice(open + 1, i).trim();
+    }
+    return undefined;
+}
+function extractSpringData(symbols, filePath, _source) {
+    const relations = [];
+    const repositories = new Set();
+    for (const iface of symbols) {
+        if (iface.filePath !== filePath || iface.kind !== "interface")
+            continue;
+        const shape = repositoryShape(iface);
+        if (!shape)
+            continue;
+        repositories.add(iface.id);
+        relations.push({
+            kind: "PERSISTS_ENTITY",
+            family: "spring-data-jpa",
+            sourceSymbolId: iface.id,
+            targetLabel: shape.entity,
+            confidence: "unresolved", // provisional until resolvePersistsEntity runs
+            evidence: [`extends ${shape.matched}`, `id type: ${shape.id}`],
+            range: iface.range,
+            filePath,
+        });
+    }
+    for (const method of symbols) {
+        if (method.kind !== "method" || !method.parentId || !repositories.has(method.parentId))
+            continue;
+        const properties = derivedProperties(method.name);
+        const query = queryText(method);
+        if (!properties && query === undefined)
+            continue;
+        relations.push({
+            kind: "REPOSITORY_QUERY",
+            family: "spring-data-jpa",
+            sourceSymbolId: method.id,
+            targetLabel: properties ? `${method.name.match(DERIVED_RE)[0]}: ${properties.map((p) => p.slice(10)).join(", ")}` : "query",
+            confidence: "exact",
+            evidence: [...(properties ?? []), ...(query !== undefined ? [query] : [])],
+            range: method.range,
+            filePath,
+        });
+    }
+    return relations;
+}
+/** Same rule as DI bean identity: 1 match exact, 0 dropped, 2+ unresolved (never guessed). */
+function resolvePersistsEntity(relations, allSymbols) {
+    const projectTypes = allSymbols.filter((s) => s.kind === "class" || s.kind === "interface");
+    return relations.flatMap((r) => {
+        if (r.kind !== "PERSISTS_ENTITY" || r.family !== "spring-data-jpa")
+            return [r];
+        const candidates = projectTypes.filter((s) => s.name === r.targetLabel);
+        if (candidates.length === 0)
+            return [];
+        const { targetSymbolId: _stale, ...rest } = r;
+        if (candidates.length > 1)
+            return [{ ...rest, confidence: "unresolved" }];
+        return [{ ...rest, confidence: "exact", targetSymbolId: candidates[0].id }];
+    });
+}
+/**
+ * Real-repository finding (petclinic-rest): a "plain" repository interface with NO generic of
+ * its own (e.g. `OwnerRepository`, no `<Entity, Id>`) declares the derived-query methods the
+ * service layer actually calls, while a separate sibling (e.g. `SpringDataOwnerRepository`)
+ * `extends OwnerRepository, Repository<Owner, Integer>` and re-declares only SOME of them. Under
+ * per-file extraction alone, the plain interface's methods get zero REPOSITORY_QUERY relations,
+ * because repositoryShape() only recognizes an interface that itself carries the `<Entity, Id>`
+ * generic. This resolver closes that gap: once an interface's PERSISTS_ENTITY has resolved
+ * "exact" (so we know its entity with certainty, never a guess), walk its own supertype chain
+ * (SymbolRecord.supertypes — plain identifier list, already stripped of generics by the parser)
+ * and, for every reachable supertype that is itself a project interface with NO generic shape of
+ * its own (so it wasn't already extracted directly), run the exact same derived-query/@Query
+ * extraction on its methods, attributing REPOSITORY_QUERY relations to the SAME entity the
+ * subinterface resolved. A supertype name that doesn't resolve to exactly one project interface
+ * (ambiguous or external, e.g. the framework's own `Repository`) is skipped, never guessed —
+ * same discipline as resolvePersistsEntity and resolveEntityRelations.
+ *
+ * ponytail: SymbolRecord.supertypes (java-parser.ts) is built from a regex that stops at the
+ * first `<`, so a supertype list like `extends Repository<Owner, Integer>, OwnerRepository`
+ * (generic-bearing supertype listed FIRST) loses `OwnerRepository` entirely — this only works
+ * reliably when the plain supertype is listed before the generic one, which happens to be every
+ * real occurrence seen so far (petclinic-rest always writes the plain interface first). If a
+ * real repository is found with the generic-first ordering, the parser's supertypes regex needs
+ * fixing (shared file — full shared-file discipline applies), not this resolver.
+ */
+function resolveRepositoryQueryPropagation(relations, allSymbols) {
+    const persistsByInterface = new Map();
+    for (const r of relations) {
+        if (r.kind === "PERSISTS_ENTITY" && r.family === "spring-data-jpa" && r.confidence === "exact") {
+            persistsByInterface.set(r.sourceSymbolId, r);
+        }
+    }
+    if (persistsByInterface.size === 0)
+        return relations;
+    const interfacesByName = new Map();
+    const interfaceById = new Map();
+    for (const s of allSymbols) {
+        if (s.kind !== "interface")
+            continue;
+        interfaceById.set(s.id, s);
+        const list = interfacesByName.get(s.name) ?? [];
+        list.push(s);
+        interfacesByName.set(s.name, list);
+    }
+    const existingQuerySources = new Set(relations.filter((r) => r.kind === "REPOSITORY_QUERY" && r.family === "spring-data-jpa").map((r) => r.sourceSymbolId));
+    const added = [];
+    for (const ifaceId of persistsByInterface.keys()) {
+        const iface = interfaceById.get(ifaceId);
+        if (!iface)
+            continue;
+        const visited = new Set([iface.id]);
+        const queue = [...(iface.supertypes ?? [])];
+        while (queue.length) {
+            const name = queue.shift();
+            const candidates = interfacesByName.get(name);
+            if (!candidates || candidates.length !== 1)
+                continue; // unresolved/ambiguous/external: never guess
+            const supIface = candidates[0];
+            if (visited.has(supIface.id))
+                continue;
+            visited.add(supIface.id);
+            queue.push(...(supIface.supertypes ?? []));
+            if (persistsByInterface.has(supIface.id))
+                continue; // has its own generic: already extracted directly
+            for (const method of allSymbols) {
+                if (method.kind !== "method" || method.parentId !== supIface.id)
+                    continue;
+                if (existingQuerySources.has(method.id))
+                    continue;
+                const properties = derivedProperties(method.name);
+                const query = queryText(method);
+                if (!properties && query === undefined)
+                    continue;
+                added.push({
+                    kind: "REPOSITORY_QUERY",
+                    family: "spring-data-jpa",
+                    sourceSymbolId: method.id,
+                    targetLabel: properties ? `${method.name.match(DERIVED_RE)[0]}: ${properties.map((p) => p.slice(10)).join(", ")}` : "query",
+                    confidence: "exact",
+                    evidence: [...(properties ?? []), ...(query !== undefined ? [query] : []), `propagated from ${supIface.name} via ${iface.name}`],
+                    range: method.range,
+                    filePath: method.filePath,
+                });
+                existingQuerySources.add(method.id);
+            }
+        }
+    }
+    return added.length === 0 ? relations : [...relations, ...added];
+}
+registerEnterpriseExtractor(extractSpringData);
+registerEnterpriseResolver(resolvePersistsEntity);
+registerEnterpriseResolver(resolveRepositoryQueryPropagation);

package/dist/src/languages/java/enterprise/spring-mvc.js

@@ -0,0 +1,183 @@
+import { registerEnterpriseExtractor } from "./registry.js";
+/**
+ * Spring MVC mapping annotation -> HTTP method label. A bare @RequestMapping's
+ * `method = RequestMethod.X` attribute is out of scope for this phase (known
+ * limitation): every @RequestMapping, regardless of any method= attribute,
+ * maps to "REQUEST" rather than being parsed into a real verb.
+ */
+const MAPPING_ANNOTATIONS = {
+    RequestMapping: "REQUEST",
+    GetMapping: "GET",
+    PostMapping: "POST",
+    PutMapping: "PUT",
+    DeleteMapping: "DELETE",
+    PatchMapping: "PATCH",
+};
+const CONST_RE_TEMPLATE = (name) => new RegExp(`(?:static\\s+final|final\\s+static)\\s+String\\s+${name}\\s*=\\s*"([^"]*)"`);
+/** Strips a leading "@" and any dotted package prefix, e.g. "@org.springframework...GetMapping" -> "GetMapping". */
+function bareName(annotation) {
+    return annotation.slice(annotation.lastIndexOf(".") + 1).replace("@", "");
+}
+/**
+ * Matches ONE specific, already-AST-confirmed mapping annotation's own argument text.
+ * Detection of WHICH annotation (if any) is present happens via SymbolRecord.annotations,
+ * never via this regex — this only ever runs to extract an argument list for an annotation
+ * name already known to be real, eliminating the false-positive risk a generic multi-name
+ * scan over raw text would have (e.g. matching annotation-shaped text inside a comment).
+ * The optional `(?:[\w.]+\.)?` prefix tolerates a fully-qualified annotation name (e.g.
+ * "@org.springframework.web.bind.annotation.GetMapping(...)") the same way bareName()
+ * already tolerates one for detection — without it, a qualified annotation would be
+ * correctly DETECTED (via .annotations) but its argument text would never be found,
+ * silently downgrading every qualified-annotation route to a path-less "probable" result
+ * instead of the fully-resolved "exact" one it should get.
+ */
+function mappingArgsRegex(name) {
+    return new RegExp(`@(?:[\\w.]+\\.)?${name}(?:\\(([^)]*)\\))?`);
+}
+/**
+ * The symbol's own header text (annotations + declaration), stopping before its body's
+ * opening "{". A naive indexOf("{") breaks when a mapping annotation's path literal itself
+ * contains "{" (e.g. "/{id}"), so this tracks string-literal and paren depth to find the
+ * real body brace instead.
+ */
+function header(symbol) {
+    const text = symbol.source;
+    let inString = false;
+    let depth = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '"' && text[i - 1] !== "\\")
+            inString = !inString;
+        if (inString)
+            continue;
+        if (ch === "(")
+            depth++;
+        else if (ch === ")")
+            depth--;
+        else if (ch === "{" && depth === 0)
+            return text.slice(0, i);
+    }
+    return text;
+}
+/**
+ * Resolves a mapping annotation's argument text to a path.
+ * - A quoted string literal is exact.
+ * - A same-class `static final String NAME = "literal"` constant resolves through
+ *   one hop, downgrading confidence to at most "probable".
+ * - An array literal (`{"/a", "/b"}`, including a single-element `{"/a"}`) is never
+ *   treated as an unambiguous single route; its first element resolves through the
+ *   same "probable" downgrade as a const hop, with the raw `{...}` text kept in
+ *   evidence so a developer can see it was an array.
+ * - Anything else (a call, a qualified constant, a placeholder) is unresolved;
+ *   the raw expression is kept for evidence/targetLabel, never guessed into a path.
+ */
+function resolvePath(rawInside, classSource) {
+    if (rawInside === undefined)
+        return { kind: "absent" };
+    let text = rawInside.trim();
+    if (text === "")
+        return { kind: "absent" };
+    // produces=/consumes=/a bare method= attribute (no value=/path= alongside it) isn't a
+    // path argument at all — treat it the same as no path, never as a fabricated route.
+    if (/^(?:produces|consumes|method)\s*=/.test(text) && !/\b(?:value|path)\s*=/.test(text)) {
+        return { kind: "absent" };
+    }
+    text = text.replace(/^(?:value|path)\s*=\s*/, "").trim();
+    // An array literal (`{"/a", "/b"}`) is never a single exact route — take the first
+    // element but downgrade to "probable" (like a const hop), never "exact".
+    if (text.startsWith("{")) {
+        const firstElement = text.match(/"([^"]*)"/);
+        if (firstElement)
+            return { kind: "array", value: firstElement[1] };
+        return { kind: "unresolved", raw: text };
+    }
+    // Only a literal that IS the whole argument value counts — not string concatenation
+    // (`Paths.P + "/x"`) or a quoted substring buried inside other tokens.
+    const quoted = text.match(/^"([^"]*)"$/);
+    if (quoted)
+        return { kind: "literal", value: quoted[1] };
+    const identMatch = text.match(/^([A-Za-z_$][\w$]*)$/);
+    if (identMatch) {
+        const match = classSource.match(CONST_RE_TEMPLATE(identMatch[1]));
+        if (match)
+            return { kind: "const", value: match[1] };
+    }
+    return { kind: "unresolved", raw: text };
+}
+function joinPaths(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return `${a.replace(/\/+$/, "")}/${b.replace(/^\/+/, "")}`;
+}
+function describeAnnotation(name, rawInside, kind, symbolName) {
+    const args = rawInside !== undefined ? `(${rawInside.trim()})` : "";
+    return `@${name}${args} on ${kind} ${symbolName}`;
+}
+function extractSpringMvcRelations(symbols, filePath, source) {
+    const relations = [];
+    const classes = symbols.filter((s) => s.kind === "class");
+    for (const method of symbols.filter((s) => s.kind === "method")) {
+        const parent = classes.find((c) => c.id === method.parentId);
+        const methodAnnotationName = method.annotations
+            .map(bareName)
+            .find((name) => name in MAPPING_ANNOTATIONS);
+        if (!methodAnnotationName)
+            continue; // not a handler: no annotation spam for non-mapped methods
+        const httpMethod = MAPPING_ANNOTATIONS[methodAnnotationName];
+        const methodMatch = header(method).match(mappingArgsRegex(methodAnnotationName));
+        const classSourceForConstants = parent?.source ?? "";
+        const methodResolution = resolvePath(methodMatch?.[1], classSourceForConstants);
+        const evidence = [];
+        let classAnnotationName;
+        let classRawInside;
+        if (parent) {
+            classAnnotationName = parent.annotations.map(bareName).find((name) => name in MAPPING_ANNOTATIONS);
+            if (classAnnotationName) {
+                const classMatch = header(parent).match(mappingArgsRegex(classAnnotationName));
+                classRawInside = classMatch?.[1];
+                evidence.push(describeAnnotation(classAnnotationName, classRawInside, "class", parent.name));
+            }
+        }
+        evidence.push(describeAnnotation(methodAnnotationName, methodMatch?.[1], "method", method.name));
+        let confidence;
+        let targetLabel;
+        const classResolution = classAnnotationName
+            ? resolvePath(classRawInside, classSourceForConstants)
+            : { kind: "absent" };
+        if (methodResolution.kind === "unresolved") {
+            confidence = "unresolved";
+            targetLabel = methodResolution.raw;
+        }
+        else if (classResolution.kind === "unresolved") {
+            confidence = "unresolved";
+            targetLabel = classResolution.raw;
+        }
+        else {
+            const classPath = classResolution.kind === "absent" ? "" : classResolution.value;
+            const methodPath = methodResolution.kind === "absent" ? "" : methodResolution.value;
+            const usedConstOrArrayHop = classResolution.kind === "const" ||
+                methodResolution.kind === "const" ||
+                classResolution.kind === "array" ||
+                methodResolution.kind === "array";
+            // No path text resolved anywhere (e.g. a produces=-only mapping with no class prefix):
+            // never claim "exact" for a route that has no actual path evidence behind it.
+            const noPathAtAll = classPath === "" && methodPath === "";
+            confidence = usedConstOrArrayHop || noPathAtAll ? "probable" : "exact";
+            targetLabel = `${httpMethod} ${joinPaths(classPath, methodPath)}`.trimEnd();
+        }
+        relations.push({
+            kind: "ROUTE_TO_HANDLER",
+            family: "spring-mvc",
+            sourceSymbolId: method.id,
+            targetLabel,
+            confidence,
+            evidence,
+            range: method.range,
+            filePath,
+        });
+    }
+    return relations;
+}
+registerEnterpriseExtractor(extractSpringMvcRelations);

package/dist/src/languages/java/enterprise/transactions.js

@@ -0,0 +1,110 @@
+import { registerEnterpriseExtractor } from "./registry.js";
+const KEPT_ATTRS = new Set(["readOnly", "propagation", "isolation", "rollbackFor", "noRollbackFor", "timeout"]);
+/** Strips a leading "@" and any dotted package prefix, e.g. "@org.springframework...Transactional" -> "Transactional". */
+function bareName(annotation) {
+    return annotation.slice(annotation.lastIndexOf(".") + 1).replace("@", "");
+}
+/**
+ * Matches an already-AST-confirmed @Transactional annotation's own argument text. Detection
+ * of whether the annotation is present happens via SymbolRecord.annotations, never via this
+ * regex -- this only ever runs to extract an argument list once .annotations has confirmed
+ * the annotation is real. The optional `(?:[\w.]+\.)?` prefix tolerates a fully-qualified
+ * annotation name the same way bareName() already tolerates one for detection -- without it,
+ * a qualified @Transactional would be correctly DETECTED but its attributes would never be
+ * found, silently downgrading it to "no fact to record" (the same brief's Review Focus item 2).
+ */
+function transactionalArgsRegex() {
+    return /@(?:[\w.]+\.)?Transactional(?:\(([^]*?)\))?/;
+}
+/**
+ * The symbol's own header text (annotations + declaration), stopping before its body's
+ * opening "{". Same string/paren-depth-aware scan as spring-mvc.ts's header(), re-derived
+ * here (each family extractor is self-contained, per convention) rather than imported —
+ * a naive indexOf("{") would misfire if an attribute value ever contained a brace.
+ */
+function header(symbol) {
+    const text = symbol.source;
+    let inString = false;
+    let depth = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '"' && text[i - 1] !== "\\")
+            inString = !inString;
+        if (inString)
+            continue;
+        if (ch === "(")
+            depth++;
+        else if (ch === ")")
+            depth--;
+        else if (ch === "{" && depth === 0)
+            return text.slice(0, i);
+    }
+    return text;
+}
+/** Splits an annotation argument list on commas outside (), strings, so dotted constants
+ * (Propagation.REQUIRES_NEW) and .class literals never get mis-split. */
+function splitTopLevel(text) {
+    const parts = [];
+    let inString = false;
+    let depth = 0;
+    let last = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '"' && text[i - 1] !== "\\")
+            inString = !inString;
+        if (inString)
+            continue;
+        if (ch === "(")
+            depth++;
+        else if (ch === ")")
+            depth--;
+        else if (ch === "," && depth === 0) {
+            parts.push(text.slice(last, i));
+            last = i + 1;
+        }
+    }
+    parts.push(text.slice(last));
+    return parts.map((p) => p.trim()).filter(Boolean);
+}
+function extractTransactionRelations(symbols, filePath, source) {
+    const relations = [];
+    for (const method of symbols.filter((s) => s.kind === "method")) {
+        const hasTransactional = method.annotations.some((a) => bareName(a) === "Transactional");
+        if (!hasTransactional)
+            continue;
+        const match = header(method).match(transactionalArgsRegex());
+        const rawArgs = match?.[1];
+        if (rawArgs === undefined || rawArgs.trim() === "")
+            continue; // bare or empty-parens: no fact to record
+        const evidence = [];
+        for (const pair of splitTopLevel(rawArgs)) {
+            const eq = pair.indexOf("=");
+            if (eq === -1)
+                continue;
+            const name = pair.slice(0, eq).trim();
+            if (!KEPT_ATTRS.has(name))
+                continue;
+            evidence.push(pair.replace(/\s+/g, " ").trim());
+        }
+        if (evidence.length === 0)
+            continue;
+        const targetLabel = evidence
+            .map((e) => {
+            const eq = e.indexOf("=");
+            return `${e.slice(0, eq).trim()}=${e.slice(eq + 1).trim()}`;
+        })
+            .join(", ");
+        relations.push({
+            kind: "TRANSACTION_BOUNDARY",
+            family: "transactions",
+            sourceSymbolId: method.id,
+            targetLabel,
+            confidence: "exact",
+            evidence,
+            range: method.range,
+            filePath,
+        });
+    }
+    return relations;
+}
+registerEnterpriseExtractor(extractTransactionRelations);

package/dist/src/languages/java.js

@@ -0,0 +1,84 @@
+import { parseJava } from "../parser/java-parser.js";
+import { registerLanguage, } from "./adapter.js";
+export const javaAdapter = {
+    id: "java",
+    label: "Java",
+    extensions: [".java"],
+    ignoredDirectories: ["target", ".gradle"],
+    parse(filePath, source) {
+        const parsed = parseJava(filePath, source);
+        return { ...parsed, imports: [], exports: [] };
+    },
+    resolveCalls({ symbols, calls, sourceOf }) {
+        for (const call of calls) {
+            const caller = symbols.find((symbol) => symbol.id === call.callerId);
+            if (!caller)
+                continue;
+            const parent = symbols.find((symbol) => symbol.id === caller.parentId);
+            const candidates = symbols.filter((symbol) => (symbol.kind === "method" || symbol.kind === "constructor") &&
+                symbol.name === call.calleeName);
+            const sameType = candidates.filter((candidate) => candidate.parentId === caller.parentId);
+            const source = sourceOf(caller);
+            const declaredType = call.receiverText
+                ? (source.match(new RegExp(`(?:\\b([A-Za-z_$][\\w$]*)\\s+${call.receiverText}\\b|\\b([A-Za-z_$][\\w$]*)\\s+${call.receiverText}\\s*[=;])`))?.[1] ??
+                    source.match(new RegExp(`\\b([A-Za-z_$][\\w$]*)\\s+${call.receiverText}\\b`))?.[1])
+                : undefined;
+            const receiverType = declaredType ??
+                (call.receiverText && /^[A-Z]/.test(call.receiverText)
+                    ? call.receiverText
+                    : undefined);
+            const typed = receiverType
+                ? candidates.filter((candidate) => symbols.find((symbol) => symbol.id === candidate.parentId)
+                    ?.name === receiverType)
+                : [];
+            const inherited = parent?.supertypes?.flatMap((supertype) => candidates.filter((candidate) => symbols.find((symbol) => symbol.id === candidate.parentId)
+                ?.name === supertype)) ?? [];
+            const narrowed = (items) => call.argumentCount === undefined
+                ? items
+                : items.filter((candidate) => (candidate.signature?.match(/\(([^)]*)\)/)?.[1].trim()
+                    ? candidate.signature.match(/\(([^)]*)\)/)[1].split(",")
+                        .length
+                    : 0) === call.argumentCount);
+            const options = call.resolutionKind === "constructor"
+                ? narrowed(candidates.filter((candidate) => candidate.kind === "constructor"))
+                : receiverType
+                    ? narrowed(typed)
+                    : sameType.length
+                        ? narrowed(sameType)
+                        : narrowed(inherited);
+            if (options.length === 1) {
+                const target = options[0];
+                call.declaredTargetId = target.id;
+                call.resolvedTargetId = target.id;
+                call.confidence =
+                    receiverType &&
+                        symbols.find((symbol) => symbol.id === target.parentId)?.kind ===
+                            "interface"
+                        ? "probable"
+                        : "exact";
+                call.resolutionKind =
+                    call.resolutionKind === "constructor"
+                        ? "constructor"
+                        : inherited.includes(target)
+                            ? "inherited"
+                            : receiverType
+                                ? symbols.find((symbol) => symbol.id === target.parentId)
+                                    ?.kind === "interface"
+                                    ? "interface"
+                                    : /^[A-Z]/.test(call.receiverText ?? "")
+                                        ? "static"
+                                        : "explicit-receiver"
+                                : "same-type";
+                call.evidence = [
+                    `unique ${call.resolutionKind} target ${target.qualifiedName}`,
+                ];
+            }
+            else if (options.length > 1) {
+                call.confidence = "unresolved";
+                call.resolutionKind = receiverType ? "interface" : "unresolved";
+                call.evidence = [`${options.length} plausible targets remain`];
+            }
+        }
+    },
+};
+registerLanguage(javaAdapter);

package/dist/src/languages/javascript/index.js

@@ -0,0 +1,25 @@
+import { registerLanguage } from "../adapter.js";
+import { JAVASCRIPT_LANGUAGE_ID, parseTypeScript } from "../typescript/parse.js";
+import { resolveTypeScriptCalls } from "../typescript/resolve.js";
+// Reuses the TypeScript grammar/parser: JS syntax is a subset of TS, and parseTypeScript
+// already derives the right language id and JSX-vs-plain grammar per file extension.
+export const javaScriptAdapter = {
+    id: JAVASCRIPT_LANGUAGE_ID,
+    label: "JavaScript",
+    extensions: [".jsx", ".mjs", ".cjs", ".js"],
+    ignoredDirectories: [
+        "node_modules",
+        ".next",
+        ".nuxt",
+        ".turbo",
+        ".cache",
+        "coverage",
+        "storybook-static",
+    ],
+    parse: parseTypeScript,
+    resolveCalls: (context) => {
+        resolveTypeScriptCalls(context);
+    },
+};
+registerLanguage(javaScriptAdapter);
+export { JAVASCRIPT_LANGUAGE_ID };

package/dist/src/languages/python/index.js

@@ -0,0 +1,29 @@
+import { registerLanguage } from "../adapter.js";
+import { LANGUAGE_ID, parsePython } from "./parse.js";
+import { pythonDiagnostics, resolvePythonCalls } from "./resolve.js";
+export const pythonAdapter = {
+    id: LANGUAGE_ID,
+    label: "Python",
+    extensions: [".py", ".pyi"],
+    ignoredDirectories: [
+        "__pycache__",
+        ".venv",
+        "venv",
+        "env",
+        "site-packages",
+        ".pytest_cache",
+        ".mypy_cache",
+        ".pyright",
+        ".ruff_cache",
+        ".tox",
+        ".nox",
+        ".eggs",
+    ],
+    parse: parsePython,
+    resolveCalls: (context) => {
+        resolvePythonCalls(context);
+    },
+};
+registerLanguage(pythonAdapter);
+export { pythonDiagnostics };
+export { LANGUAGE_ID as PYTHON_LANGUAGE_ID };