gitnexus 1.4.10 → 1.5.0

package/dist/core/ingestion/heritage-processor.js

@@ -16,7 +16,7 @@
 import Parser from 'tree-sitter';
 import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename } from './utils/language-detection.js';
+import { getLanguageFromFilename } from 'gitnexus-shared';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
 import { getProvider } from './languages/index.js';
@@ -30,7 +30,8 @@ import { TIER_CONFIDENCE } from './resolution-context.js';
  *   - heritageDefaultEdge: 'IMPLEMENTS' causes all unresolved parents to map to IMPLEMENTS
  *   - All others: default EXTENDS
  */
-const resolveExtendsType = (parentName, currentFilePath, ctx, language) => {
+/** Exported for implementor-map construction (C#/Java: `extends` rows in base_list may be interfaces). */
+export const resolveExtendsType = (parentName, currentFilePath, ctx, language) => {
     const resolved = ctx.resolve(parentName, currentFilePath);
     if (resolved && resolved.candidates.length > 0) {
         const isInterface = resolved.candidates[0].type === 'Interface';
@@ -53,12 +54,18 @@ const resolveHeritageId = (name, filePath, ctx, fallbackLabel, fallbackKey) => {
     if (resolved && resolved.candidates.length > 0) {
         // For global with multiple candidates, refuse (a wrong edge is worse than no edge)
         if (resolved.tier === 'global' && resolved.candidates.length > 1) {
-            return { id: generateId(fallbackLabel, fallbackKey ?? name), confidence: TIER_CONFIDENCE['global'] };
+            return {
+                id: generateId(fallbackLabel, fallbackKey ?? name),
+                confidence: TIER_CONFIDENCE['global'],
+            };
         }
         return { id: resolved.candidates[0].nodeId, confidence: TIER_CONFIDENCE[resolved.tier] };
     }
     // Unresolved: use global-tier confidence as fallback
-    return { id: generateId(fallbackLabel, fallbackKey ?? name), confidence: TIER_CONFIDENCE['global'] };
+    return {
+        id: generateId(fallbackLabel, fallbackKey ?? name),
+        confidence: TIER_CONFIDENCE['global'],
+    };
 };
 export const processHeritage = async (graph, files, astCache, ctx, onProgress) => {
     const parser = await loadParser();
@@ -90,7 +97,9 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
         if (!tree) {
             // Use larger bufferSize for files > 32KB
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parser.parse(file.content, undefined, {
+                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                });
             }
             catch (parseError) {
                 // Skip files that can't be parsed
@@ -111,9 +120,9 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
             continue;
         }
         // 4. Process heritage matches
-        matches.forEach(match => {
+        matches.forEach((match) => {
             const captureMap = {};
-            match.captures.forEach(c => {
+            match.captures.forEach((c) => {
                 captureMap[c.name] = c.node;
             });
             // EXTENDS or IMPLEMENTS: resolve via symbol table for languages where
@@ -228,7 +237,10 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx
                 });
             }
         }
-        else if (h.kind === 'trait-impl' || h.kind === 'include' || h.kind === 'extend' || h.kind === 'prepend') {
+        else if (h.kind === 'trait-impl' ||
+            h.kind === 'include' ||
+            h.kind === 'extend' ||
+            h.kind === 'prepend') {
             const strct = resolveHeritageId(h.className, h.filePath, ctx, 'Struct', `${h.filePath}:${h.className}`);
             const trait = resolveHeritageId(h.parentName, h.filePath, ctx, 'Trait');
             if (strct.id && trait.id) {
@@ -245,3 +257,82 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx
     }
     onProgress?.(total, total);
 };
+/**
+ * Walk source files with the same heritage captures as parse-worker, producing
+ * {@link ExtractedHeritage} rows without mutating the graph. Used on the
+ * sequential pipeline path so `buildImplementorMap(..., ctx)` can run before
+ * `processCalls` (worker path defers calls until heritage from all chunks exists).
+ */
+export async function extractExtractedHeritageFromFiles(files, astCache) {
+    const parser = await loadParser();
+    const out = [];
+    for (const file of files) {
+        const language = getLanguageFromFilename(file.path);
+        if (!language || !isLanguageAvailable(language))
+            continue;
+        const provider = getProvider(language);
+        const queryStr = provider.treeSitterQueries;
+        if (!queryStr)
+            continue;
+        await loadLanguage(language, file.path);
+        let tree = astCache.get(file.path);
+        if (!tree) {
+            try {
+                tree = parser.parse(file.content, undefined, {
+                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                });
+            }
+            catch {
+                continue;
+            }
+            astCache.set(file.path, tree);
+        }
+        let matches;
+        try {
+            const lang = parser.getLanguage();
+            const query = new Parser.Query(lang, queryStr);
+            matches = query.matches(tree.rootNode);
+        }
+        catch {
+            continue;
+        }
+        for (const match of matches) {
+            const captureMap = {};
+            match.captures.forEach((c) => {
+                captureMap[c.name] = c.node;
+            });
+            if (captureMap['heritage.class']) {
+                if (captureMap['heritage.extends']) {
+                    const extendsNode = captureMap['heritage.extends'];
+                    const fieldDecl = extendsNode.parent;
+                    const isNamedField = fieldDecl?.type === 'field_declaration' && fieldDecl.childForFieldName('name');
+                    if (!isNamedField) {
+                        out.push({
+                            filePath: file.path,
+                            className: captureMap['heritage.class'].text,
+                            parentName: captureMap['heritage.extends'].text,
+                            kind: 'extends',
+                        });
+                    }
+                }
+                if (captureMap['heritage.implements']) {
+                    out.push({
+                        filePath: file.path,
+                        className: captureMap['heritage.class'].text,
+                        parentName: captureMap['heritage.implements'].text,
+                        kind: 'implements',
+                    });
+                }
+                if (captureMap['heritage.trait']) {
+                    out.push({
+                        filePath: file.path,
+                        className: captureMap['heritage.class'].text,
+                        parentName: captureMap['heritage.trait'].text,
+                        kind: 'trait-impl',
+                    });
+                }
+            }
+        }
+    }
+    return out;
+}

package/dist/core/ingestion/import-processor.js

@@ -2,7 +2,7 @@ import Parser from 'tree-sitter';
 import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { getProvider, getProviderForFile, providersWithImplicitWiring } from './languages/index.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename } from './utils/language-detection.js';
+import { getLanguageFromFilename } from 'gitnexus-shared';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
 import { getTreeSitterBufferSize } from './constants.js';
@@ -47,7 +47,7 @@ export function isFileInPackageDir(filePath, dirSuffix) {
 // ImportResolutionContext is defined in ./import-resolvers/types.ts — re-exported here for consumers.
 export function buildImportResolutionContext(allPaths) {
     const allFileList = allPaths;
-    const normalizedFileList = allFileList.map(p => p.replace(/\\/g, '/'));
+    const normalizedFileList = allFileList.map((p) => p.replace(/\\/g, '/'));
     const allFilePaths = new Set(allFileList);
     const index = buildSuffixIndex(normalizedFileList, allFileList);
     return { allFilePaths, allFileList, normalizedFileList, index, resolveCache: new Map() };
@@ -80,7 +80,14 @@ function createImportEdgeHelpers(graph, importMap) {
         const targetId = generateId('File', resolvedPath);
         const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
         totalImportsResolved++;
-        graph.addRelationship({ id: relId, sourceId, targetId, type: 'IMPORTS', confidence: 1.0, reason: '' });
+        graph.addRelationship({
+            id: relId,
+            sourceId,
+            targetId,
+            type: 'IMPORTS',
+            confidence: 1.0,
+            reason: '',
+        });
     };
     const addImportEdge = (filePath, resolvedPath) => {
         addImportGraphEdge(filePath, resolvedPath);
@@ -147,7 +154,10 @@ function applyImportResult(result, filePath, importMap, packageMap, addImportEdg
                         fileBindings.delete(binding.local);
                     }
                     else {
-                        fileBindings.set(binding.local, { sourcePath: resolvedFile, exportedName: binding.exported });
+                        fileBindings.set(binding.local, {
+                            sourcePath: resolvedFile,
+                            exportedName: binding.exported,
+                        });
                     }
                 }
             }
@@ -159,7 +169,7 @@ function applyImportResult(result, filePath, importMap, packageMap, addImportEdg
                     if (binding.isModuleAlias)
                         continue;
                     const lowerName = binding.exported.toLowerCase();
-                    const matchedFile = files.find(f => {
+                    const matchedFile = files.find((f) => {
                         const base = f.replace(/\\/g, '/').split('/').pop() ?? '';
                         const nameWithoutExt = base.substring(0, base.lastIndexOf('.')).toLowerCase();
                         return nameWithoutExt === lowerName;
@@ -170,7 +180,10 @@ function applyImportResult(result, filePath, importMap, packageMap, addImportEdg
                             fileBindings.delete(binding.local);
                         }
                         else {
-                            fileBindings.set(binding.local, { sourcePath: matchedFile, exportedName: binding.exported });
+                            fileBindings.set(binding.local, {
+                                sourcePath: matchedFile,
+                                exportedName: binding.exported,
+                            });
                         }
                     }
                 }
@@ -187,21 +200,28 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
     const namedImportMap = ctx.namedImportMap;
     const moduleAliasMap = ctx.moduleAliasMap;
     // Use allPaths (full repo) when available for cross-chunk resolution, else fall back to chunk files
-    const allFileList = allPaths ?? files.map(f => f.path);
+    const allFileList = allPaths ?? files.map((f) => f.path);
     const allFilePaths = new Set(allFileList);
     const parser = await loadParser();
     const logSkipped = isVerboseIngestionEnabled();
     const skippedByLang = logSkipped ? new Map() : null;
     const resolveCache = new Map();
     // Pre-compute normalized file list once (forward slashes)
-    const normalizedFileList = allFileList.map(p => p.replace(/\\/g, '/'));
+    const normalizedFileList = allFileList.map((p) => p.replace(/\\/g, '/'));
     // Build suffix index for O(1) lookups
     const index = buildSuffixIndex(normalizedFileList, allFileList);
     // Track import statistics
     let totalImportsFound = 0;
     // Load language-specific configs once before the file loop
     const configs = await loadImportConfigs(repoRoot || '');
-    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache, configs };
+    const resolveCtx = {
+        allFilePaths,
+        allFileList,
+        normalizedFileList,
+        index,
+        resolveCache,
+        configs,
+    };
     const { addImportEdge, addImportGraphEdge, getResolvedCount } = createImportEdgeHelpers(graph, importMap);
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
@@ -229,7 +249,9 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
         let wasReparsed = false;
         if (!tree) {
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parser.parse(file.content, undefined, {
+                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                });
             }
             catch (parseError) {
                 continue;
@@ -260,9 +282,9 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
                 tree.delete?.();
             continue;
         }
-        matches.forEach(match => {
+        matches.forEach((match) => {
             const captureMap = {};
-            match.captures.forEach(c => captureMap[c.name] = c.node);
+            match.captures.forEach((c) => (captureMap[c.name] = c.node));
             if (captureMap['import']) {
                 const sourceNode = captureMap['import.source'];
                 if (!sourceNode) {
@@ -313,11 +335,18 @@ export const processImportsFromExtracted = async (graph, files, extractedImports
     const packageMap = ctx.packageMap;
     const namedImportMap = ctx.namedImportMap;
     const moduleAliasMap = ctx.moduleAliasMap;
-    const importCtx = prebuiltCtx ?? buildImportResolutionContext(files.map(f => f.path));
+    const importCtx = prebuiltCtx ?? buildImportResolutionContext(files.map((f) => f.path));
     const { allFilePaths, allFileList, normalizedFileList, index, resolveCache } = importCtx;
     let totalImportsFound = 0;
     const configs = await loadImportConfigs(repoRoot || '');
-    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache, configs };
+    const resolveCtx = {
+        allFilePaths,
+        allFileList,
+        normalizedFileList,
+        index,
+        resolveCache,
+        configs,
+    };
     const { addImportEdge, addImportGraphEdge, getResolvedCount } = createImportEdgeHelpers(graph, importMap);
     // Group by file for progress reporting (users see file count, not import count)
     const importsByFile = new Map();
@@ -345,7 +374,7 @@ export const processImportsFromExtracted = async (graph, files, extractedImports
         }
     }
     onProgress?.(totalFiles, totalFiles);
-    wireImplicitImports(files.map(f => f.path), importMap, addImportEdge, configs);
+    wireImplicitImports(files.map((f) => f.path), importMap, addImportEdge, configs);
     if (isDev) {
         console.log(`📊 Import processing (fast path): ${getResolvedCount()}/${totalImportsFound} imports resolved to graph edges`);
     }

package/dist/core/ingestion/import-resolvers/csharp.js

@@ -3,7 +3,7 @@
  * Handles using-directive resolution via .csproj root namespace stripping.
  */
 import { suffixResolve } from './utils.js';
-import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { SupportedLanguages } from 'gitnexus-shared';
 import { resolveStandard } from './standard.js';
 /**
  * Resolve a C# using-directive import path to matching .cs files (low-level helper).
@@ -26,7 +26,9 @@ export function resolveCSharpImportInternal(importPath, csharpConfigs, normalize
             continue;
         }
         const dirPrefix = config.projectDir
-            ? (relative ? config.projectDir + '/' + relative : config.projectDir)
+            ? relative
+                ? config.projectDir + '/' + relative
+                : config.projectDir
             : relative;
         // 1. Try as single file: relative.cs (e.g., "Models/DlqMessage.cs")
         if (relative) {
@@ -101,7 +103,9 @@ export function resolveCSharpNamespaceDir(importPath, csharpConfigs) {
             continue;
         }
         const dirPrefix = config.projectDir
-            ? (relative ? config.projectDir + '/' + relative : config.projectDir)
+            ? relative
+                ? config.projectDir + '/' + relative
+                : config.projectDir
             : relative;
         if (!dirPrefix)
             continue;

package/dist/core/ingestion/import-resolvers/dart.js

@@ -4,7 +4,7 @@
  * SDK imports (dart:*) and external packages are skipped.
  */
 import { resolveStandard } from './standard.js';
-import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { SupportedLanguages } from 'gitnexus-shared';
 export function resolveDartImport(rawImportPath, filePath, ctx) {
     // Strip surrounding quotes from configurable_uri capture
     const stripped = rawImportPath.replace(/^['"]|['"]$/g, '');

package/dist/core/ingestion/import-resolvers/go.js

@@ -2,7 +2,7 @@
  * Go package import resolution.
  * Handles Go module path-based package imports.
  */
-import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { SupportedLanguages } from 'gitnexus-shared';
 import { resolveStandard } from './standard.js';
 /**
  * Extract the package directory suffix from a Go import path.
@@ -33,7 +33,9 @@ export function resolveGoPackage(importPath, goModule, normalizedFileList, allFi
         // Prepend '/' so paths like "internal/auth/service.go" match suffix "/internal/auth/"
         const normalized = '/' + normalizedFileList[i];
         // File must be directly in the package directory (not a subdirectory)
-        if (normalized.includes(pkgSuffix) && normalized.endsWith('.go') && !normalized.endsWith('_test.go')) {
+        if (normalized.includes(pkgSuffix) &&
+            normalized.endsWith('.go') &&
+            !normalized.endsWith('_test.go')) {
             const afterPkg = normalized.substring(normalized.indexOf(pkgSuffix) + pkgSuffix.length);
             if (!afterPkg.includes('/')) {
                 matches.push(allFileList[i]);

package/dist/core/ingestion/import-resolvers/jvm.js

@@ -2,7 +2,7 @@
  * JVM import resolution (Java + Kotlin).
  * Handles wildcard imports, member/static imports, and Kotlin-specific patterns.
  */
-import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { SupportedLanguages } from 'gitnexus-shared';
 import { resolveStandard } from './standard.js';
 /** Kotlin file extensions for JVM resolver reuse */
 export const KOTLIN_EXTENSIONS = ['.kt', '.kts'];
@@ -26,11 +26,11 @@ export function resolveJvmWildcard(importPath, normalizedFileList, allFileList,
     // "com.example.util.*" -> "com/example/util"
     const packagePath = importPath.slice(0, -2).replace(/\./g, '/');
     if (index) {
-        const candidates = extensions.flatMap(ext => index.getFilesInDir(packagePath, ext));
+        const candidates = extensions.flatMap((ext) => index.getFilesInDir(packagePath, ext));
         // Filter to only direct children (no subdirectories)
         const packageSuffix = '/' + packagePath + '/';
         const packagePrefix = packagePath + '/';
-        return candidates.filter(f => {
+        return candidates.filter((f) => {
             const normalized = f.replace(/\\/g, '/');
             // Match both nested (src/models/User.kt) and root-level (models/User.kt) packages
             let afterPkg;
@@ -53,7 +53,7 @@ export function resolveJvmWildcard(importPath, normalizedFileList, allFileList,
     const matches = [];
     for (let i = 0; i < normalizedFileList.length; i++) {
         const normalized = normalizedFileList[i];
-        if (!extensions.some(ext => normalized.endsWith(ext)))
+        if (!extensions.some((ext) => normalized.endsWith(ext)))
             continue;
         // Match both nested (src/models/User.kt) and root-level (models/User.kt) packages
         let afterPackage = null;

package/dist/core/ingestion/import-resolvers/php.js

@@ -50,9 +50,7 @@ export function resolvePhpImportInternal(importPath, composerConfig, allFiles, n
                 // 2. Function/constant fallback: strip last segment (symbol name), scan namespace directory.
                 //    e.g. App\Models\getUser → directory app/Models/, find first .php file in that dir.
                 const lastSlash = remainder.lastIndexOf('/');
-                const nsDir = lastSlash >= 0
-                    ? dirPrefix + '/' + remainder.slice(0, lastSlash)
-                    : dirPrefix;
+                const nsDir = lastSlash >= 0 ? dirPrefix + '/' + remainder.slice(0, lastSlash) : dirPrefix;
                 // Prefer SuffixIndex directory lookup (O(log n + matches)) over linear scan
                 if (index) {
                     const candidates = index.getFilesInDir(nsDir, '.php');
@@ -62,7 +60,9 @@ export function resolvePhpImportInternal(importPath, composerConfig, allFiles, n
                 // Fallback: linear scan (only when SuffixIndex unavailable)
                 const nsDirPrefix = nsDir.endsWith('/') ? nsDir : nsDir + '/';
                 for (const f of allFiles) {
-                    if (f.startsWith(nsDirPrefix) && f.endsWith('.php') && !f.slice(nsDirPrefix.length).includes('/')) {
+                    if (f.startsWith(nsDirPrefix) &&
+                        f.endsWith('.php') &&
+                        !f.slice(nsDirPrefix.length).includes('/')) {
                         return f;
                     }
                 }

package/dist/core/ingestion/import-resolvers/python.js

@@ -3,7 +3,7 @@
  * Import system spec: PEP 302 (original), PEP 451 (current).
  */
 import { tryResolveWithExtensions } from './utils.js';
-import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { SupportedLanguages } from 'gitnexus-shared';
 import { resolveStandard } from './standard.js';
 /**
  * Resolve a Python import to a file path (low-level helper).

package/dist/core/ingestion/import-resolvers/rust.js

@@ -2,7 +2,7 @@
  * Rust module import resolution.
  * Handles crate::, super::, self:: prefix paths and :: separators.
  */
-import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { SupportedLanguages } from 'gitnexus-shared';
 import { resolveStandard } from './standard.js';
 /**
  * Resolve Rust use-path to a file (low-level helper).
@@ -78,7 +78,10 @@ export function resolveRustImport(rawImportPath, filePath, ctx) {
     // Top-level grouped: use {crate::a, crate::b}
     if (rawImportPath.startsWith('{') && rawImportPath.endsWith('}')) {
         const inner = rawImportPath.slice(1, -1);
-        const parts = inner.split(',').map(p => p.trim()).filter(Boolean);
+        const parts = inner
+            .split(',')
+            .map((p) => p.trim())
+            .filter(Boolean);
         const resolved = [];
         for (const part of parts) {
             const r = resolveRustImportInternal(filePath, part, ctx.allFilePaths);
@@ -92,7 +95,10 @@ export function resolveRustImport(rawImportPath, filePath, ctx) {
     if (braceIdx !== -1 && rawImportPath.endsWith('}')) {
         const pathPrefix = rawImportPath.substring(0, braceIdx);
         const braceContent = rawImportPath.substring(braceIdx + 3, rawImportPath.length - 1);
-        const items = braceContent.split(',').map(s => s.trim()).filter(Boolean);
+        const items = braceContent
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
         const resolved = [];
         for (const item of items) {
             // Handle `use crate::models::{User, Repo as R}` — strip alias for resolution

package/dist/core/ingestion/import-resolvers/standard.d.ts

@@ -4,7 +4,7 @@
  * Used as the fallback when language-specific resolvers don't match.
  */
 import type { SuffixIndex } from './utils.js';
-import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { SupportedLanguages } from 'gitnexus-shared';
 import type { ImportResult, ImportResolverFn, ResolveCtx } from './types.js';
 import type { TsconfigPaths } from '../language-config.js';
 /** Max entries in the resolve cache. Beyond this, entries are evicted.

package/dist/core/ingestion/import-resolvers/standard.js

@@ -5,7 +5,7 @@
  */
 import { tryResolveWithExtensions, suffixResolve } from './utils.js';
 import { resolveRustImportInternal } from './rust.js';
-import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { SupportedLanguages } from 'gitnexus-shared';
 /** Max entries in the resolve cache. Beyond this, entries are evicted.
  *  100K entries ≈ 15MB — covers the most common import patterns. */
 export const RESOLVE_CACHE_CAP = 100_000;
@@ -76,7 +76,10 @@ export const resolveImportPath = (currentFile, importPath, allFiles, allFileList
             // Rust grouped-import blocks in processImports / processImportsBatch). This fallback
             // handles any path that reaches resolveImportPath directly.
             const inner = importPath.slice(1, -1);
-            const parts = inner.split(',').map(p => p.trim()).filter(Boolean);
+            const parts = inner
+                .split(',')
+                .map((p) => p.trim())
+                .filter(Boolean);
             for (const part of parts) {
                 const partResult = resolveRustImportInternal(currentFile, part, allFiles);
                 if (partResult)
@@ -114,9 +117,7 @@ export const resolveImportPath = (currentFile, importPath, allFiles, allFileList
     }
     // C/C++ includes use actual file paths (e.g. "animal.h") — don't convert dots to slashes
     const isCpp = language === SupportedLanguages.C || language === SupportedLanguages.CPlusPlus;
-    const pathLike = importPath.includes('/') || isCpp
-        ? importPath
-        : importPath.replace(/\./g, '/');
+    const pathLike = importPath.includes('/') || isCpp ? importPath : importPath.replace(/\./g, '/');
     const pathParts = pathLike.split('/').filter(Boolean);
     const resolved = suffixResolve(pathParts, normalizedFileList, allFileList, index);
     return cache(resolved);

package/dist/core/ingestion/import-resolvers/swift.js

@@ -11,7 +11,8 @@ export function resolveSwiftImport(rawImportPath, _filePath, ctx) {
             const dirPrefix = targetDir + '/';
             const files = [];
             for (let i = 0; i < ctx.normalizedFileList.length; i++) {
-                if (ctx.normalizedFileList[i].startsWith(dirPrefix) && ctx.normalizedFileList[i].endsWith('.swift')) {
+                if (ctx.normalizedFileList[i].startsWith(dirPrefix) &&
+                    ctx.normalizedFileList[i].endsWith('.swift')) {
                     files.push(ctx.allFileList[i]);
                 }
             }

package/dist/core/ingestion/import-resolvers/utils.js

@@ -6,23 +6,41 @@
 export const EXTENSIONS = [
     '',
     // TypeScript/JavaScript
-    '.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts', '/index.jsx', '/index.js',
+    '.tsx',
+    '.ts',
+    '.jsx',
+    '.js',
+    '/index.tsx',
+    '/index.ts',
+    '/index.jsx',
+    '/index.js',
     // Python
-    '.py', '/__init__.py',
+    '.py',
+    '/__init__.py',
     // Java
     '.java',
     // Kotlin
-    '.kt', '.kts',
+    '.kt',
+    '.kts',
     // C/C++
-    '.c', '.h', '.cpp', '.hpp', '.cc', '.cxx', '.hxx', '.hh',
+    '.c',
+    '.h',
+    '.cpp',
+    '.hpp',
+    '.cc',
+    '.cxx',
+    '.hxx',
+    '.hh',
     // C#
     '.cs',
     // Go
     '.go',
     // Rust
-    '.rs', '/mod.rs',
+    '.rs',
+    '/mod.rs',
     // PHP
-    '.php', '.phtml',
+    '.php',
+    '.phtml',
     // Swift
     '.swift',
     // Ruby
@@ -119,7 +137,8 @@ export function suffixResolve(pathParts, normalizedFileList, allFileList, index)
         for (const ext of EXTENSIONS) {
             const suffixWithExt = suffix + ext;
             const suffixPattern = '/' + suffixWithExt;
-            const matchIdx = normalizedFileList.findIndex(filePath => filePath.endsWith(suffixPattern) || filePath.toLowerCase().endsWith(suffixPattern.toLowerCase()));
+            const matchIdx = normalizedFileList.findIndex((filePath) => filePath.endsWith(suffixPattern) ||
+                filePath.toLowerCase().endsWith(suffixPattern.toLowerCase()));
             if (matchIdx !== -1) {
                 return allFileList[matchIdx];
             }

package/dist/core/ingestion/language-config.js

@@ -107,7 +107,10 @@ export async function loadCSharpProjectConfig(repoRoot) {
             for (const entry of entries) {
                 if (entry.isDirectory() && depth < maxDepth) {
                     // Skip common non-project directories
-                    if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'bin' || entry.name === 'obj')
+                    if (entry.name === 'node_modules' ||
+                        entry.name === '.git' ||
+                        entry.name === 'bin' ||
+                        entry.name === 'obj')
                         continue;
                     scanQueue.push({ dir: path.join(dir, entry.name), depth: depth + 1 });
                 }
@@ -116,9 +119,7 @@ export async function loadCSharpProjectConfig(repoRoot) {
                         const csprojPath = path.join(dir, entry.name);
                         const content = await fs.readFile(csprojPath, 'utf-8');
                         const nsMatch = content.match(/<RootNamespace>\s*([^<]+)\s*<\/RootNamespace>/);
-                        const rootNamespace = nsMatch
-                            ? nsMatch[1].trim()
-                            : entry.name.replace(/\.csproj$/, '');
+                        const rootNamespace = nsMatch ? nsMatch[1].trim() : entry.name.replace(/\.csproj$/, '');
                         const projectDir = path.relative(repoRoot, dir).replace(/\\/g, '/');
                         configs.push({ rootNamespace, projectDir });
                         if (isDev) {

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

@@ -8,15 +8,16 @@
  * The providers table in `languages/index.ts` uses `satisfies Record<SupportedLanguages, LanguageProvider>`
  * so adding a language to the enum without creating a provider is a compiler error.
  */
-import type { SupportedLanguages } from '../../config/supported-languages.js';
+import type { SupportedLanguages } from 'gitnexus-shared';
 import type { LanguageTypeConfig } from './type-extractors/types.js';
 import type { CallRouter } from './call-routing.js';
 import type { ExportChecker } from './export-detection.js';
 import type { FieldExtractor } from './field-extractor.js';
+import type { MethodExtractor } from './method-types.js';
 import type { ImportResolverFn } from './import-resolvers/types.js';
 import type { NamedBindingExtractorFn } from './named-bindings/types.js';
 import type { SyntaxNode } from './utils/ast-helpers.js';
-import type { NodeLabel } from '../graph/types.js';
+import type { NodeLabel } from 'gitnexus-shared';
 /** Tree-sitter query captures: capture name → AST node (or undefined if not captured). */
 export type CaptureMap = Record<string, SyntaxNode | undefined>;
 /** MRO strategy for multiple inheritance resolution. */
@@ -96,6 +97,10 @@ interface LanguageProviderConfig {
      *  declarations. Produces FieldInfo[] with name, type, visibility, static,
      *  readonly metadata. Default: undefined (no field extraction). */
     readonly fieldExtractor?: FieldExtractor;
+    /** Method extractor for extracting method/function definitions from class/struct/interface
+     *  declarations. Produces MethodInfo[] with name, parameters, visibility, isAbstract,
+     *  isFinal, annotations metadata. Default: undefined (no method extraction). */
+    readonly methodExtractor?: MethodExtractor;
     /** Extract a semantic description for a definition node (e.g., PHP Eloquent
      *  property arrays, relation method descriptions).
      *  Default: undefined (no description extraction). */