gitnexus 1.6.4-rc.51 → 1.6.4-rc.53

package/dist/core/group/config-parser.js

@@ -9,7 +9,7 @@ const DEFAULT_DETECT = {
     topics: true,
     shared_libs: true,
     embedding_fallback: true,
-    workspace_deps: true,
+    workspace_deps: false,
 };
 const DEFAULT_MATCHING = {
     bm25_threshold: 0.7,

package/dist/core/group/extractors/elixir-workspace-extractor.d.ts

@@ -0,0 +1,15 @@
+import type { CypherExecutor } from '../contract-extractor.js';
+import type { GroupManifestLink } from '../types.js';
+interface ElixirAppMeta {
+    appName: string;
+    modulePrefix: string;
+    groupPath: string;
+    repoPath: string;
+    deps: string[];
+}
+export interface ElixirWorkspaceResult {
+    links: GroupManifestLink[];
+    discoveredApps: Map<string, ElixirAppMeta>;
+}
+export declare function extractElixirWorkspaceLinks(repos: Record<string, string>, repoPaths: Map<string, string>, _dbExecutors?: Map<string, CypherExecutor>): Promise<ElixirWorkspaceResult>;
+export {};

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

@@ -0,0 +1,203 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { shouldIgnorePath, loadIgnoreRules } from '../../../config/ignore-service.js';
+async function parseMixExs(repoPath) {
+    const mixPath = path.join(repoPath, 'mix.exs');
+    let content;
+    try {
+        content = await fs.readFile(mixPath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    // app: :my_app
+    const appMatch = content.match(/app:\s*:(\w+)/);
+    if (!appMatch)
+        return null;
+    const appName = appMatch[1];
+    // Derive module prefix: my_app -> MyApp
+    const modulePrefix = appName
+        .split('_')
+        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+        .join('');
+    const deps = [];
+    // {:dep_name, "~> 1.0"} or {:dep_name, in_umbrella: true}
+    // {:dep_name, git: "..."} or {:dep_name, path: "..."}
+    const depMatches = content.matchAll(/\{:(\w+)\s*,\s*(?:"[^"]*"|~[^}]*|[^}]*(?:in_umbrella|path|git)\s*:[^}]*)\}/g);
+    for (const m of depMatches) {
+        deps.push(m[1]);
+    }
+    return { appName, modulePrefix, deps: [...new Set(deps)] };
+}
+async function scanElixirImports(repoPath, knownApps) {
+    const results = [];
+    const sourceFiles = await findElixirFiles(repoPath);
+    for (const relFile of sourceFiles) {
+        const absPath = path.join(repoPath, relFile);
+        let content;
+        try {
+            content = await fs.readFile(absPath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        // alias MyApp.SomeModule
+        // alias MyApp.SomeModule, as: Short
+        // alias MyApp.{ModA, ModB}
+        const aliasRegex = /^\s*alias\s+([A-Z]\w+(?:\.[A-Z]\w+)*(?:\.\{[^}]+\})?)/gm;
+        let match;
+        while ((match = aliasRegex.exec(content)) !== null) {
+            const aliasExpr = match[1];
+            const modules = expandAlias(aliasExpr);
+            for (const mod of modules) {
+                const appName = matchModuleToApp(mod, knownApps);
+                if (appName) {
+                    results.push({ appName, moduleName: mod, filePath: relFile });
+                }
+            }
+        }
+        // Direct module reference: MyApp.Module.func() or MyApp.Module
+        // Strip comment lines and string literals to avoid false positives
+        const codeOnly = content
+            .split('\n')
+            .filter((line) => !line.trimStart().startsWith('#'))
+            .join('\n');
+        for (const [prefix, appName] of knownApps) {
+            const refRegex = new RegExp(`\\b(${escapeRegex(prefix)}\\.[A-Z][A-Za-z0-9]*(?:\\.[A-Z][A-Za-z0-9]*)*)`, 'g');
+            while ((match = refRegex.exec(codeOnly)) !== null) {
+                const mod = match[1];
+                if (!results.some((r) => r.moduleName === mod && r.filePath === relFile)) {
+                    results.push({ appName, moduleName: mod, filePath: relFile });
+                }
+            }
+        }
+    }
+    return results;
+}
+function expandAlias(expr) {
+    const braceMatch = expr.match(/^([A-Z][\w.]*)\.\{([^}]+)\}$/);
+    if (braceMatch) {
+        const prefix = braceMatch[1];
+        return braceMatch[2]
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean)
+            .map((s) => `${prefix}.${s}`);
+    }
+    return [expr];
+}
+function matchModuleToApp(moduleName, knownApps) {
+    for (const [prefix, appName] of knownApps) {
+        if (moduleName === prefix || moduleName.startsWith(prefix + '.')) {
+            return appName;
+        }
+    }
+    return null;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function extractTopModule(moduleName, prefix) {
+    const rest = moduleName.slice(prefix.length);
+    if (!rest || rest === '.')
+        return moduleName;
+    const afterDot = rest.startsWith('.') ? rest.slice(1) : rest;
+    const parts = afterDot.split('.');
+    return `${prefix}.${parts[0]}`;
+}
+async function findElixirFiles(repoPath) {
+    const results = [];
+    const ig = await loadIgnoreRules(repoPath);
+    async function walk(dir, rel) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (shouldIgnorePath(childRel))
+                    continue;
+                if (ig && ig.ignores(childRel + '/'))
+                    continue;
+                await walk(path.join(dir, entry.name), childRel);
+            }
+            else if (entry.name.endsWith('.ex') || entry.name.endsWith('.exs')) {
+                if (entry.name === 'mix.exs' || entry.name === 'mix.lock')
+                    continue;
+                if (shouldIgnorePath(childRel))
+                    continue;
+                if (ig && ig.ignores(childRel))
+                    continue;
+                results.push(childRel);
+            }
+        }
+    }
+    await walk(repoPath, '');
+    return results;
+}
+export async function extractElixirWorkspaceLinks(repos, repoPaths, _dbExecutors) {
+    const appsByName = new Map();
+    const appsByGroupPath = new Map();
+    for (const [groupPath] of Object.entries(repos)) {
+        const repoPath = repoPaths.get(groupPath);
+        if (!repoPath)
+            continue;
+        const manifest = await parseMixExs(repoPath);
+        if (!manifest)
+            continue;
+        const meta = {
+            appName: manifest.appName,
+            modulePrefix: manifest.modulePrefix,
+            groupPath,
+            repoPath,
+            deps: manifest.deps,
+        };
+        const existing = appsByName.get(manifest.appName);
+        if (existing) {
+            console.warn(`[elixir-workspace-extractor] duplicate app "${manifest.appName}" in "${groupPath}" and "${existing.groupPath}" — skipping "${groupPath}"`);
+            continue;
+        }
+        appsByName.set(manifest.appName, meta);
+        appsByGroupPath.set(groupPath, meta);
+    }
+    const links = [];
+    const seen = new Set();
+    for (const [, app] of appsByGroupPath) {
+        const groupDeps = app.deps.filter((d) => appsByName.has(d));
+        if (groupDeps.length === 0)
+            continue;
+        const knownApps = new Map();
+        for (const dep of groupDeps) {
+            const depMeta = appsByName.get(dep);
+            if (depMeta)
+                knownApps.set(depMeta.modulePrefix, dep);
+        }
+        const imports = await scanElixirImports(app.repoPath, knownApps);
+        for (const imp of imports) {
+            const providerApp = appsByName.get(imp.appName);
+            if (!providerApp)
+                continue;
+            const topModule = extractTopModule(imp.moduleName, providerApp.modulePrefix);
+            const key = `${app.groupPath}→${providerApp.groupPath}::${topModule}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            // V1: Elixir contracts use the full module name (e.g. "Core.Schema") without
+            // an "appName::" prefix. resolveSymbol will query the graph with this full
+            // string — resolution depends on Elixir indexer storing fully-qualified names.
+            const link = {
+                from: providerApp.groupPath,
+                to: app.groupPath,
+                type: 'custom',
+                contract: topModule,
+                role: 'provider',
+            };
+            links.push(link);
+        }
+    }
+    return { links, discoveredApps: appsByGroupPath };
+}

package/dist/core/group/extractors/go-workspace-extractor.d.ts

@@ -0,0 +1,14 @@
+import type { CypherExecutor } from '../contract-extractor.js';
+import type { GroupManifestLink } from '../types.js';
+interface GoModuleMeta {
+    modulePath: string;
+    groupPath: string;
+    repoPath: string;
+    requires: string[];
+}
+export interface GoWorkspaceResult {
+    links: GroupManifestLink[];
+    discoveredModules: Map<string, GoModuleMeta>;
+}
+export declare function extractGoWorkspaceLinks(repos: Record<string, string>, repoPaths: Map<string, string>, _dbExecutors?: Map<string, CypherExecutor>): Promise<GoWorkspaceResult>;
+export {};

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

@@ -0,0 +1,216 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { shouldIgnorePath, loadIgnoreRules } from '../../../config/ignore-service.js';
+async function parseGoMod(repoPath) {
+    const goModPath = path.join(repoPath, 'go.mod');
+    let content;
+    try {
+        content = await fs.readFile(goModPath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    const moduleMatch = content.match(/^module\s+(\S+)/m);
+    if (!moduleMatch)
+        return null;
+    const modulePath = moduleMatch[1];
+    const requires = [];
+    // Single-line: require github.com/org/repo v1.2.3
+    const singleReqs = content.matchAll(/^require\s+(\S+)\s+/gm);
+    for (const m of singleReqs)
+        requires.push(m[1]);
+    // Block: require ( ... )
+    const blockReqs = content.matchAll(/^require\s*\(\s*\n([\s\S]*?)\)/gm);
+    for (const block of blockReqs) {
+        const lines = block[1].split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('//'))
+                continue;
+            const parts = trimmed.split(/\s+/);
+            if (parts[0])
+                requires.push(parts[0]);
+        }
+    }
+    // replace directives (local path deps)
+    const replaceLines = content.matchAll(/^replace\s+(\S+)\s+=>\s+\.\//gm);
+    for (const m of replaceLines) {
+        if (!requires.includes(m[1]))
+            requires.push(m[1]);
+    }
+    const replaceBlocks = content.matchAll(/^replace\s*\(\s*\n([\s\S]*?)\)/gm);
+    for (const block of replaceBlocks) {
+        const lines = block[1].split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('//'))
+                continue;
+            const match = trimmed.match(/^(\S+)\s+=>\s+\.\//);
+            if (match && !requires.includes(match[1]))
+                requires.push(match[1]);
+        }
+    }
+    return { modulePath, requires: [...new Set(requires)] };
+}
+async function scanGoImports(repoPath, knownModules) {
+    const results = [];
+    const sourceFiles = await findGoFiles(repoPath);
+    for (const relFile of sourceFiles) {
+        const absPath = path.join(repoPath, relFile);
+        let content;
+        try {
+            content = await fs.readFile(absPath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const importPaths = extractImportPaths(content);
+        for (const importPath of importPaths) {
+            const matchedModule = findMatchingModule(importPath, knownModules);
+            if (!matchedModule)
+                continue;
+            const symbols = extractUsedTypes(content, importPath);
+            for (const sym of symbols) {
+                results.push({ modulePath: matchedModule, symbolName: sym, filePath: relFile });
+            }
+        }
+    }
+    return results;
+}
+function extractImportPaths(content) {
+    const paths = [];
+    // Single: import "path"
+    const singleImports = content.matchAll(/^import\s+"([^"]+)"/gm);
+    for (const m of singleImports)
+        paths.push(m[1]);
+    // Single aliased: import alias "path"
+    const aliasedImports = content.matchAll(/^import\s+\w+\s+"([^"]+)"/gm);
+    for (const m of aliasedImports)
+        paths.push(m[1]);
+    // Block: import ( ... )
+    const blockImports = content.matchAll(/^import\s*\(\s*\n([\s\S]*?)\)/gm);
+    for (const block of blockImports) {
+        const lines = block[1].split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('//'))
+                continue;
+            const pathMatch = trimmed.match(/"([^"]+)"/);
+            if (pathMatch)
+                paths.push(pathMatch[1]);
+        }
+    }
+    return [...new Set(paths)];
+}
+function findMatchingModule(importPath, knownModules) {
+    for (const [modPath] of knownModules) {
+        if (importPath === modPath || importPath.startsWith(modPath + '/')) {
+            return modPath;
+        }
+    }
+    return null;
+}
+function extractUsedTypes(content, importPath) {
+    const pkgName = importPath.split('/').pop() || '';
+    if (!pkgName)
+        return [];
+    // Match pkg.TypeName where TypeName is PascalCase (exported)
+    const typeRegex = new RegExp(`\\b${escapeRegex(pkgName)}\\.([A-Z][A-Za-z0-9]*)`, 'g');
+    const types = new Set();
+    let match;
+    while ((match = typeRegex.exec(content)) !== null) {
+        types.add(match[1]);
+    }
+    return [...types];
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+async function findGoFiles(repoPath) {
+    const results = [];
+    const ig = await loadIgnoreRules(repoPath);
+    async function walk(dir, rel) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (shouldIgnorePath(childRel))
+                    continue;
+                if (ig && ig.ignores(childRel + '/'))
+                    continue;
+                await walk(path.join(dir, entry.name), childRel);
+            }
+            else if (entry.name.endsWith('.go') && !entry.name.endsWith('_test.go')) {
+                if (shouldIgnorePath(childRel))
+                    continue;
+                if (ig && ig.ignores(childRel))
+                    continue;
+                results.push(childRel);
+            }
+        }
+    }
+    await walk(repoPath, '');
+    return results;
+}
+export async function extractGoWorkspaceLinks(repos, repoPaths, _dbExecutors) {
+    const modulesByPath = new Map();
+    const modulesByGroupPath = new Map();
+    for (const [groupPath] of Object.entries(repos)) {
+        const repoPath = repoPaths.get(groupPath);
+        if (!repoPath)
+            continue;
+        const manifest = await parseGoMod(repoPath);
+        if (!manifest)
+            continue;
+        const meta = {
+            modulePath: manifest.modulePath,
+            groupPath,
+            repoPath,
+            requires: manifest.requires,
+        };
+        const existing = modulesByPath.get(manifest.modulePath);
+        if (existing) {
+            console.warn(`[go-workspace-extractor] duplicate module "${manifest.modulePath}" in "${groupPath}" and "${existing.groupPath}" — skipping "${groupPath}"`);
+            continue;
+        }
+        modulesByPath.set(manifest.modulePath, meta);
+        modulesByGroupPath.set(groupPath, meta);
+    }
+    const links = [];
+    const seen = new Set();
+    for (const [, mod] of modulesByGroupPath) {
+        const groupModDeps = mod.requires.filter((r) => modulesByPath.has(r));
+        if (groupModDeps.length === 0)
+            continue;
+        const knownModules = new Map();
+        for (const dep of groupModDeps) {
+            knownModules.set(dep, dep);
+        }
+        const imports = await scanGoImports(mod.repoPath, knownModules);
+        for (const imp of imports) {
+            const providerMod = modulesByPath.get(imp.modulePath);
+            if (!providerMod)
+                continue;
+            const qualifiedContract = `${imp.modulePath}::${imp.symbolName}`;
+            const key = `${mod.groupPath}→${providerMod.groupPath}::${qualifiedContract}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const link = {
+                from: providerMod.groupPath,
+                to: mod.groupPath,
+                type: 'custom',
+                contract: qualifiedContract,
+                role: 'provider',
+            };
+            links.push(link);
+        }
+    }
+    return { links, discoveredModules: modulesByGroupPath };
+}

package/dist/core/group/extractors/java-workspace-extractor.d.ts

@@ -0,0 +1,16 @@
+import type { CypherExecutor } from '../contract-extractor.js';
+import type { GroupManifestLink } from '../types.js';
+interface JavaProjectMeta {
+    groupId: string;
+    artifactId: string;
+    basePackage: string;
+    groupPath: string;
+    repoPath: string;
+    deps: string[];
+}
+export interface JavaWorkspaceResult {
+    links: GroupManifestLink[];
+    discoveredProjects: Map<string, JavaProjectMeta>;
+}
+export declare function extractJavaWorkspaceLinks(repos: Record<string, string>, repoPaths: Map<string, string>, _dbExecutors?: Map<string, CypherExecutor>): Promise<JavaWorkspaceResult>;
+export {};

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

@@ -0,0 +1,203 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { shouldIgnorePath, loadIgnoreRules } from '../../../config/ignore-service.js';
+async function parseJavaManifest(repoPath) {
+    const pomPath = path.join(repoPath, 'pom.xml');
+    try {
+        const content = await fs.readFile(pomPath, 'utf-8');
+        return parsePom(content);
+    }
+    catch {
+        // fall through to Gradle
+    }
+    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);
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function parsePom(content) {
+    const projectGroupMatch = content.match(/<project[^>]*>[\s\S]*?<groupId>([^<]+)<\/groupId>/);
+    const projectArtifactMatch = content.match(/<project[^>]*>[\s\S]*?<artifactId>([^<]+)<\/artifactId>/);
+    if (!projectGroupMatch || !projectArtifactMatch)
+        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()}`);
+        }
+    }
+    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] : '';
+    if (!groupId)
+        return null;
+    const artifactId = dirName;
+    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]}`);
+        }
+    }
+    // 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}`);
+    }
+    return { groupId, artifactId, deps: [...new Set(deps)] };
+}
+function deriveBasePackage(groupId, artifactId) {
+    const sanitized = artifactId.replace(/-/g, '.');
+    if (groupId.endsWith(`.${sanitized}`) || groupId === sanitized) {
+        return groupId;
+    }
+    return `${groupId}.${sanitized}`;
+}
+async function scanJavaImports(repoPath, knownPackages) {
+    const results = [];
+    const sourceFiles = await findJavaFiles(repoPath);
+    for (const relFile of sourceFiles) {
+        const absPath = path.join(repoPath, relFile);
+        let content;
+        try {
+            content = await fs.readFile(absPath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const importRegex = /^import\s+(?:static\s+)?([a-zA-Z][\w.]*\.[A-Z]\w*)/gm;
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+            const fullImport = match[1];
+            for (const [basePkg, artifactKey] of knownPackages) {
+                if (fullImport.startsWith(basePkg + '.') || fullImport === basePkg) {
+                    const parts = fullImport.split('.');
+                    const className = parts[parts.length - 1];
+                    if (isPascalCase(className)) {
+                        results.push({
+                            artifactKey,
+                            symbolName: className,
+                            filePath: relFile,
+                        });
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    return results;
+}
+function isPascalCase(name) {
+    return /^[A-Z][A-Za-z0-9]*$/.test(name);
+}
+async function findJavaFiles(repoPath) {
+    const results = [];
+    const ig = await loadIgnoreRules(repoPath);
+    async function walk(dir, rel) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (shouldIgnorePath(childRel))
+                    continue;
+                if (ig && ig.ignores(childRel + '/'))
+                    continue;
+                await walk(path.join(dir, entry.name), childRel);
+            }
+            else if (entry.name.endsWith('.java') || entry.name.endsWith('.kt')) {
+                if (shouldIgnorePath(childRel))
+                    continue;
+                if (ig && ig.ignores(childRel))
+                    continue;
+                results.push(childRel);
+            }
+        }
+    }
+    await walk(repoPath, '');
+    return results;
+}
+export async function extractJavaWorkspaceLinks(repos, repoPaths, _dbExecutors) {
+    const projectsByKey = new Map();
+    const projectsByGroupPath = new Map();
+    for (const [groupPath] of Object.entries(repos)) {
+        const repoPath = repoPaths.get(groupPath);
+        if (!repoPath)
+            continue;
+        const manifest = await parseJavaManifest(repoPath);
+        if (!manifest)
+            continue;
+        const key = `${manifest.groupId}:${manifest.artifactId}`;
+        const meta = {
+            groupId: manifest.groupId,
+            artifactId: manifest.artifactId,
+            basePackage: deriveBasePackage(manifest.groupId, manifest.artifactId),
+            groupPath,
+            repoPath,
+            deps: manifest.deps,
+        };
+        const existing = projectsByKey.get(key);
+        if (existing) {
+            console.warn(`[java-workspace-extractor] duplicate artifact "${key}" in "${groupPath}" and "${existing.groupPath}" — skipping "${groupPath}"`);
+            continue;
+        }
+        projectsByKey.set(key, meta);
+        projectsByGroupPath.set(groupPath, meta);
+    }
+    const links = [];
+    const seen = new Set();
+    for (const [, proj] of projectsByGroupPath) {
+        const groupDeps = proj.deps.filter((d) => projectsByKey.has(d));
+        if (groupDeps.length === 0)
+            continue;
+        const knownPackages = new Map();
+        for (const dep of groupDeps) {
+            const depMeta = projectsByKey.get(dep);
+            if (depMeta)
+                knownPackages.set(depMeta.basePackage, dep);
+        }
+        const imports = await scanJavaImports(proj.repoPath, knownPackages);
+        for (const imp of imports) {
+            const providerProj = projectsByKey.get(imp.artifactKey);
+            if (!providerProj)
+                continue;
+            const qualifiedContract = `${providerProj.artifactId}::${imp.symbolName}`;
+            const dedupKey = `${proj.groupPath}→${providerProj.groupPath}::${qualifiedContract}`;
+            if (seen.has(dedupKey))
+                continue;
+            seen.add(dedupKey);
+            const link = {
+                from: providerProj.groupPath,
+                to: proj.groupPath,
+                type: 'custom',
+                contract: qualifiedContract,
+                role: 'provider',
+            };
+            links.push(link);
+        }
+    }
+    return { links, discoveredProjects: projectsByGroupPath };
+}