gitnexus 1.6.11-rc.17 → 1.6.11-rc.19

package/dist/core/group/extractors/java-workspace-extractor.js

@@ -1,7 +1,20 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { XMLParser } from 'fast-xml-parser';
 import { shouldIgnorePath, loadIgnoreRules } from '../../../config/ignore-service.js';
 import { logger } from '../../logger.js';
+// POMs are static metadata. Parse hierarchy with a real XML parser, but do not
+// invoke Maven or resolve the effective model. Properties, profiles, and remote
+// parent resolution remain outside this extractor's deterministic boundary.
+const pomParser = new XMLParser({
+    ignoreAttributes: true,
+    removeNSPrefix: true,
+    trimValues: true,
+    parseTagValue: false,
+    processEntities: false,
+    ignoreDeclaration: true,
+    ignorePiTags: true,
+});
 async function parseJavaManifest(repoPath) {
     const pomPath = path.join(repoPath, 'pom.xml');
     try {
@@ -9,13 +22,14 @@ async function parseJavaManifest(repoPath) {
         return parsePom(content);
     }
     catch {
-        // fall through to Gradle
+        // Missing pom.xml — fall through to Gradle.
     }
+    const gradleSidecars = await readGradleSidecars(repoPath);
     for (const name of ['build.gradle.kts', 'build.gradle']) {
         const gradlePath = path.join(repoPath, name);
         try {
             const content = await fs.readFile(gradlePath, 'utf-8');
-            return parseGradle(content, repoPath);
+            return parseGradle(content, repoPath, gradleSidecars);
         }
         catch {
             continue;
@@ -23,45 +37,244 @@ async function parseJavaManifest(repoPath) {
     }
     return null;
 }
+async function readIfPresent(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readGradleSidecars(repoPath) {
+    const [properties, settingsKts, settingsGroovy, catalog] = await Promise.all([
+        readIfPresent(path.join(repoPath, 'gradle.properties')),
+        readIfPresent(path.join(repoPath, 'settings.gradle.kts')),
+        readIfPresent(path.join(repoPath, 'settings.gradle')),
+        readIfPresent(path.join(repoPath, 'gradle', 'libs.versions.toml')),
+    ]);
+    const sidecars = {
+        catalogLibraries: new Map(),
+        catalogBundles: new Map(),
+    };
+    const groupMatch = properties?.match(/(?:^|\n)\s*group\s*=\s*([^\s#]+)/);
+    if (groupMatch)
+        sidecars.propertiesGroup = groupMatch[1];
+    const settings = settingsKts ?? settingsGroovy;
+    const nameMatch = settings?.match(/rootProject\.name\s*=\s*['"]([^'"]+)['"]/);
+    if (nameMatch)
+        sidecars.rootProjectName = nameMatch[1];
+    if (catalog) {
+        const parsed = parseGradleVersionCatalog(catalog);
+        sidecars.catalogLibraries = parsed.libraries;
+        sidecars.catalogBundles = parsed.bundles;
+    }
+    return sidecars;
+}
+function catalogAccessors(alias) {
+    const dotted = alias.replace(/[-_]/g, '.');
+    const camel = alias.replace(/[-_]+([A-Za-z0-9])/g, (_, char) => char.toUpperCase());
+    return [...new Set([alias, dotted, camel])];
+}
+function projectAccessorToArtifactId(accessor) {
+    const last = accessor.split('.').pop();
+    return last.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`).replace(/^-/, '');
+}
+function moduleToGa(module) {
+    const parts = module.split(':');
+    return parts.length >= 2 ? `${parts[0]}:${parts[1]}` : undefined;
+}
+function parseInlineTomlTable(rhs) {
+    const fields = {};
+    for (const match of rhs.matchAll(/([A-Za-z0-9_-]+)\s*=\s*['"]([^'"]+)['"]/g)) {
+        fields[match[1]] = match[2];
+    }
+    return fields;
+}
+/** Default Gradle catalog (`gradle/libs.versions.toml`) — aliases only, no version resolution. */
+function parseGradleVersionCatalog(toml) {
+    const libraries = new Map();
+    const bundles = new Map();
+    let section = 'other';
+    const addLibrary = (alias, ga) => {
+        for (const accessor of catalogAccessors(alias))
+            libraries.set(accessor, ga);
+    };
+    for (const raw of toml.split(/\r?\n/)) {
+        const line = raw.replace(/#.*$/, '').trim();
+        if (!line)
+            continue;
+        const header = line.match(/^\[([^\]]+)\]$/);
+        if (header) {
+            const name = header[1];
+            section =
+                name === 'libraries' || name.endsWith('.libraries')
+                    ? 'libraries'
+                    : name === 'bundles' || name.endsWith('.bundles')
+                        ? 'bundles'
+                        : 'other';
+            continue;
+        }
+        if (section === 'libraries') {
+            const dottedModule = line.match(/^([A-Za-z0-9._-]+)\.module\s*=\s*['"]([^'"]+)['"]$/);
+            if (dottedModule) {
+                const ga = moduleToGa(dottedModule[2]);
+                if (ga)
+                    addLibrary(dottedModule[1], ga);
+                continue;
+            }
+            const assignment = line.match(/^([A-Za-z0-9._-]+)\s*=\s*(.+)$/);
+            if (!assignment)
+                continue;
+            const alias = assignment[1];
+            const rhs = assignment[2].trim();
+            const quoted = rhs.match(/^['"]([^'"]+)['"]$/);
+            if (quoted) {
+                const ga = moduleToGa(quoted[1]);
+                if (ga)
+                    addLibrary(alias, ga);
+                continue;
+            }
+            const table = parseInlineTomlTable(rhs);
+            const ga = table.module
+                ? moduleToGa(table.module)
+                : table.group && table.name
+                    ? `${table.group}:${table.name}`
+                    : undefined;
+            if (ga)
+                addLibrary(alias, ga);
+            continue;
+        }
+        if (section === 'bundles') {
+            const assignment = line.match(/^([A-Za-z0-9._-]+)\s*=\s*\[([^\]]*)\]$/);
+            if (!assignment)
+                continue;
+            const members = [...assignment[2].matchAll(/['"]([^'"]+)['"]/g)].map((match) => match[1]);
+            for (const accessor of catalogAccessors(assignment[1]))
+                bundles.set(accessor, members);
+        }
+    }
+    return { libraries, bundles };
+}
+const GRADLE_GROUP_PATTERNS = [
+    /(?:^|[\n{;])\s*(?:rootProject\.)?group\s*=\s*['"]([^'"]+)['"]/,
+    /(?:^|[\n{;])\s*group\s+['"]([^'"]+)['"]/,
+];
+const GRADLE_COORD_CONFIGS = 'implementation|api|compileOnly|runtimeOnly|testImplementation|testApi|testCompileOnly|compile|kapt|ksp|commonMainImplementation|commonMainApi';
+const CATALOG_ALIAS = '([A-Za-z0-9_]+(?:\\.[A-Za-z0-9_]+)*)(?:\\.get\\(\\)|\\.asProvider\\(\\))?';
+function gradleDepRe(suffix) {
+    return new RegExp(`(?:${GRADLE_COORD_CONFIGS})\\s*${suffix}`, 'g');
+}
+function parseGradleGroup(content) {
+    for (const pattern of GRADLE_GROUP_PATTERNS) {
+        const match = content.match(pattern);
+        if (match?.[1])
+            return match[1];
+    }
+    return undefined;
+}
+function asXmlNode(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function xmlText(value) {
+    if (typeof value === 'string' || typeof value === 'number') {
+        const text = String(value).trim();
+        return text || undefined;
+    }
+    const nested = asXmlNode(value)?.['#text'];
+    if (nested === undefined)
+        return undefined;
+    return xmlText(nested);
+}
+function xmlChildText(node, name) {
+    return node ? xmlText(node[name]) : undefined;
+}
+function asList(value) {
+    if (value === undefined || value === null)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+/** Direct project dependencies only — not BOM, profiles, or plugin classpath. */
+function collectProjectDependencies(project, deps) {
+    const dependencies = asXmlNode(project.dependencies);
+    if (!dependencies)
+        return;
+    for (const dep of asList(dependencies.dependency)) {
+        const depNode = asXmlNode(dep);
+        const groupId = xmlChildText(depNode, 'groupId');
+        const artifactId = xmlChildText(depNode, 'artifactId');
+        if (groupId && artifactId)
+            deps.push(`${groupId}:${artifactId}`);
+    }
+}
 function parsePom(content) {
-    const projectGroupMatch = content.match(/<project[^>]*>[\s\S]*?<groupId>([^<]+)<\/groupId>/);
-    const projectArtifactMatch = content.match(/<project[^>]*>[\s\S]*?<artifactId>([^<]+)<\/artifactId>/);
-    if (!projectGroupMatch || !projectArtifactMatch)
+    let parsed;
+    try {
+        // parseSourceSafe guards tree-sitter's Windows SIGSEGV by switching to a
+        // chunked input callback above 16 KB; XMLParser only accepts XML text, so
+        // routing POMs through it silently yields an empty document.
+        // eslint-disable-next-line gitnexus/require-safe-parse
+        parsed = pomParser.parse(content);
+    }
+    catch {
         return null;
-    const groupId = projectGroupMatch[1].trim();
-    const artifactId = projectArtifactMatch[1].trim();
-    const deps = [];
-    const depBlocks = content.matchAll(/<dependency>\s*([\s\S]*?)<\/dependency>/g);
-    for (const block of depBlocks) {
-        const gMatch = block[1].match(/<groupId>([^<]+)<\/groupId>/);
-        const aMatch = block[1].match(/<artifactId>([^<]+)<\/artifactId>/);
-        if (gMatch && aMatch) {
-            deps.push(`${gMatch[1].trim()}:${aMatch[1].trim()}`);
-        }
     }
+    const project = asXmlNode(asXmlNode(parsed)?.project);
+    if (!project)
+        return null;
+    // Maven inherits groupId from <parent>, but artifactId is always the
+    // project's own direct child and must never fall back to parent.artifactId.
+    const groupId = xmlChildText(project, 'groupId') ?? xmlChildText(asXmlNode(project.parent), 'groupId');
+    const artifactId = xmlChildText(project, 'artifactId');
+    if (!groupId || !artifactId)
+        return null;
+    const deps = [];
+    collectProjectDependencies(project, deps);
     return { groupId, artifactId, deps: [...new Set(deps)] };
 }
-function parseGradle(content, repoPath) {
-    const groupMatch = content.match(/group\s*=\s*['"]([^'"]+)['"]/);
-    const dirName = path.basename(repoPath);
-    const groupId = groupMatch ? groupMatch[1] : '';
+function parseGradle(content, repoPath, sidecars = { catalogLibraries: new Map(), catalogBundles: new Map() }) {
+    // Static text + default catalog file. Do not execute Gradle.
+    const groupId = parseGradleGroup(content) ?? sidecars.propertiesGroup ?? '';
     if (!groupId)
         return null;
-    const artifactId = dirName;
+    const artifactId = sidecars.rootProjectName ?? path.basename(repoPath);
+    const { catalogLibraries, catalogBundles } = sidecars;
     const deps = [];
-    // implementation("group:artifact:version") or api("group:artifact:version")
-    const depMatches = content.matchAll(/(?:implementation|api|compileOnly|runtimeOnly)\s*\(\s*['"]([^'"]+)['"]\s*\)/g);
-    for (const m of depMatches) {
-        const parts = m[1].split(':');
-        if (parts.length >= 2) {
-            deps.push(`${parts[0]}:${parts[1]}`);
+    const pushCatalogAlias = (alias) => {
+        const ga = catalogLibraries.get(alias);
+        if (ga)
+            deps.push(ga);
+    };
+    const namedPattern = gradleDepRe(`(?:\\(\\s*)?(?:group\\s*=\\s*['"](?<group1>[^'"]+)['"]\\s*,\\s*name\\s*=\\s*['"](?<name1>[^'"]+)['"]|name\\s*=\\s*['"](?<name2>[^'"]+)['"]\\s*,\\s*group\\s*=\\s*['"](?<group2>[^'"]+)['"]|group:\\s*['"](?<group3>[^'"]+)['"]\\s*,\\s*name:\\s*['"](?<name3>[^'"]+)['"]|name:\\s*['"](?<name4>[^'"]+)['"]\\s*,\\s*group:\\s*['"](?<group4>[^'"]+)['"])`);
+    for (const match of content.matchAll(namedPattern)) {
+        const group = match.groups?.group1 ?? match.groups?.group2 ?? match.groups?.group3 ?? match.groups?.group4;
+        const name = match.groups?.name1 ?? match.groups?.name2 ?? match.groups?.name3 ?? match.groups?.name4;
+        if (group && name)
+            deps.push(`${group}:${name}`);
+    }
+    for (const match of content.matchAll(gradleDepRe(`(?:\\(\\s*)?libs(?:\\.libraries)?\\.(?!bundles\\.|plugins\\.)${CATALOG_ALIAS}`))) {
+        pushCatalogAlias(match[1]);
+    }
+    for (const match of content.matchAll(gradleDepRe(`(?:\\(\\s*)?libs\\.bundles\\.${CATALOG_ALIAS}`))) {
+        for (const member of catalogBundles.get(match[1]) ?? []) {
+            for (const accessor of catalogAccessors(member))
+                pushCatalogAlias(accessor);
         }
     }
-    // implementation(project(":subproject"))
-    const projDeps = content.matchAll(/(?:implementation|api)\s*\(\s*project\s*\(\s*['"]([^'"]+)['"]\s*\)\s*\)/g);
-    for (const m of projDeps) {
-        const subName = m[1].replace(/^:/, '');
-        deps.push(`${groupId}:${subName}`);
+    for (const match of content.matchAll(gradleDepRe(`\\(\\s*projects\\.([A-Za-z][A-Za-z0-9.]*)`))) {
+        deps.push(`${groupId}:${projectAccessorToArtifactId(match[1])}`);
+    }
+    for (const match of content.matchAll(gradleDepRe(`(?:\\(\\s*['"]([^'"]+)['"]\\s*\\)|['"]([^'"]+)['"])`))) {
+        const coord = match[1] ?? match[2];
+        if (!coord)
+            continue;
+        const parts = coord.split(':');
+        if (parts.length >= 2)
+            deps.push(`${parts[0]}:${parts[1]}`);
+    }
+    for (const match of content.matchAll(gradleDepRe(`(?:\\(\\s*)?project\\s*\\(\\s*['"]([^'"]+)['"]\\s*\\)`))) {
+        deps.push(`${groupId}:${match[1].replace(/^:/, '')}`);
     }
     return { groupId, artifactId, deps: [...new Set(deps)] };
 }

package/dist/core/ingestion/language-provider.d.ts

@@ -297,6 +297,49 @@ interface LanguageProviderConfig {
      * Default: undefined (no interface-inheritance route resolution).
      */
     readonly extractRouteInheritanceTypes?: (tree: Parser.Tree, filePath: string) => SharedSpringType[];
+    /**
+     * Optional post-capture emission of synthetic structure members (nodes,
+     * symbols, ownership edges) that have no AST method node — e.g. Lombok
+     * accessors. Called once per file after the capture loop, at the same
+     * post-capture site as {@link extractDecoratorRoutes}.
+     *
+     * `classOwnersByNodeId` maps in-memory tree-sitter node ids of type
+     * declarations materialized in THIS file's capture loop to their graph
+     * node ids. Keys are never persisted; they exist only for the duration
+     * of the worker pass.
+     *
+     * Default: undefined (no synthetic structure members).
+     */
+    readonly synthesizeStructureMembers?: (tree: Parser.Tree, filePath: string, classOwnersByNodeId: ReadonlyMap<number, string>) => {
+        nodes: ReadonlyArray<{
+            id: string;
+            label: string;
+            properties: Record<string, unknown>;
+        }>;
+        symbols: ReadonlyArray<{
+            filePath: string;
+            name: string;
+            nodeId: string;
+            type: string;
+            ownerId?: string;
+            parameterCount?: number;
+            requiredParameterCount?: number;
+            parameterTypes?: string[];
+            returnType?: string;
+            visibility?: string;
+            isStatic?: boolean;
+            isAbstract?: boolean;
+            isFinal?: boolean;
+        }>;
+        relationships: ReadonlyArray<{
+            id: string;
+            sourceId: string;
+            targetId: string;
+            type: string;
+            confidence: number;
+            reason: string;
+        }>;
+    };
     /**
      * Harvest this file's module-level string constants (#2391 core, #2980 Java
      * parity) into the language-agnostic {@link ModuleConstants} shape, so the

package/dist/core/ingestion/languages/java/captures.js

@@ -18,6 +18,7 @@ import { captureJavaSpringAopFacts } from './spring-aop.js';
 import { captureJavaSpringConditionalFacts, } from './spring-conditionals.js';
 import { captureJavaSpringNonHttpHandlerFacts, } from './spring-non-http-handlers.js';
 import { synthesizeJavaRecordComponentAccessorCaptures } from './record-components.js';
+import { synthesizeLombokAccessorCaptures } from './lombok-synthesizer.js';
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = ['@declaration.method', '@declaration.constructor'];
 /** tree-sitter-java node types that the method extractor accepts. */
@@ -305,6 +306,7 @@ export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
         ...synthesizeJavaExplicitConstructorReferences(tree.rootNode),
         ...synthesizeJavaAnonymousClassDeclarations(tree.rootNode),
         ...synthesizeJavaRecordComponentAccessorCaptures(tree.rootNode),
+        ...synthesizeLombokAccessorCaptures(tree.rootNode),
         ...synthesizeCallableFlowCaptures(tree.rootNode, JAVA_CALLABLE_CAPTURE_OPTIONS),
     ];
 }

package/dist/core/ingestion/languages/java/lombok-synthesizer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Lombok accessor synthesizer for Java.
+ *
+ * Lombok generates getters/setters at compile time. They are absent from the
+ * AST, so calls like `obj.getOrderId()` on a `@Data` class would otherwise
+ * leave unresolved CALLS edges. This module walks the tree-sitter Java AST
+ * and synthesizes Method graph members for the accessors Lombok would emit
+ * under the supported subset.
+ *
+ * ## Supported subset (v1)
+ * - Proven `lombok.Data` / `lombok.Getter` / `lombok.Setter` (FQN or import).
+ * - Class- or field-level enable; `AccessLevel.NONE` disables.
+ * - Default JavaBeans naming; primitive `boolean isX` → `isX` / `setX`.
+ * - Access levels PUBLIC/PROTECTED/PRIVATE/PACKAGE.
+ * - `@Accessors(chain=true)` modeled as setter return = declaring type.
+ * - `@Accessors(fluent=true)` / `prefix=…`: omit affected accessors (names
+ *   cannot be proven without full Lombok config).
+ * - External `lombok.config`: unsupported (may change semantics invisibly).
+ *
+ * ## Identity
+ * Owner lookup uses in-memory AST node ids only. Method ids are derived from
+ * the stable declaring-owner graph key (the Class node id's name segment),
+ * never from persisted tree-sitter node ids.
+ */
+import type Parser from 'tree-sitter';
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type PlannedJvmAccessor, type SyntheticAccessorResult, type SyntheticVisibility } from '../jvm/accessor-synthesis.js';
+export type LombokVisibility = SyntheticVisibility;
+export type SyntheticSymbol = SyntheticAccessorResult['symbols'][number];
+export type SyntheticNode = SyntheticAccessorResult['nodes'][number];
+export type SyntheticRelationship = SyntheticAccessorResult['relationships'][number];
+export type LombokSynthesisResult = SyntheticAccessorResult;
+export type PlannedLombokAccessor = PlannedJvmAccessor;
+export interface AccessorConfig {
+    enabled: boolean;
+    visibility: LombokVisibility;
+}
+export declare function getterName(fieldName: string, fieldType: string): string;
+export declare function setterName(fieldName: string, fieldType: string): string;
+export declare function synthesizeLombokAccessors(tree: Parser.Tree, filePath: string, classOwnersById: ReadonlyMap<number, string>): LombokSynthesisResult;
+/** Scope captures for Lombok accessors (dual-path parity with record components). */
+export declare function synthesizeLombokAccessorCaptures(rootNode: Parser.SyntaxNode): CaptureMatch[];