gitnexus 1.6.2-rc.2 → 1.6.2-rc.21

package/dist/core/ingestion/import-resolvers/resolver-factory.js

@@ -0,0 +1,33 @@
+/**
+ * Import resolver factory — creates a composable import resolver from
+ * an ordered list of strategies.
+ *
+ * Mirrors the method-extractors/generic.ts and call-extractors/generic.ts
+ * pattern: declare a config per language, produce a runtime resolver via factory.
+ *
+ * Each strategy is tried in order. The first non-null result wins.
+ * A result with an empty `files` array is treated as "handled but unresolved"
+ * (stops the chain without producing import edges).
+ */
+/**
+ * Create an ImportResolverFn from a declarative config.
+ *
+ * Chains strategies in declaration order — first non-null result wins.
+ * Returns null only if every strategy returns null.
+ *
+ * Error behaviour: if a strategy throws, the error propagates immediately
+ * and remaining strategies are not tried.  Strategies are expected to be
+ * pure data transforms that never throw; any unexpected exception indicates
+ * a bug in the strategy implementation.
+ */
+export function createImportResolver(config) {
+    const { strategies } = config;
+    return (rawImportPath, filePath, ctx) => {
+        for (const strategy of strategies) {
+            const result = strategy(rawImportPath, filePath, ctx);
+            if (result)
+                return result;
+        }
+        return null;
+    };
+}

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

@@ -1,9 +1,10 @@
 /**
- * Ruby require/require_relative import resolution.
- * Handles path resolution for Ruby's require and require_relative calls.
+ * Ruby require/require_relative import resolution — internal helpers.
+ *
+ * Strategy lives in configs/ruby.ts.
+ * This file only contains the low-level helper used by the strategy.
  */
 import type { SuffixIndex } from './utils.js';
-import type { ImportResult, ResolveCtx } from './types.js';
 /**
  * Resolve a Ruby require/require_relative path to a matching .rb file (low-level helper).
  *
@@ -11,5 +12,3 @@ import type { ImportResult, ResolveCtx } from './types.js';
  * require paths use suffix matching (gem-style paths like 'json', 'net/http').
  */
 export declare function resolveRubyImportInternal(importPath: string, normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;
-/** Ruby: require / require_relative. */
-export declare function resolveRubyImport(rawImportPath: string, _filePath: string, ctx: ResolveCtx): ImportResult;

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

@@ -1,6 +1,8 @@
 /**
- * Ruby require/require_relative import resolution.
- * Handles path resolution for Ruby's require and require_relative calls.
+ * Ruby require/require_relative import resolution — internal helpers.
+ *
+ * Strategy lives in configs/ruby.ts.
+ * This file only contains the low-level helper used by the strategy.
  */
 import { suffixResolve } from './utils.js';
 /**
@@ -13,8 +15,3 @@ export function resolveRubyImportInternal(importPath, normalizedFileList, allFil
     const pathParts = importPath.replace(/^\.\//, '').split('/').filter(Boolean);
     return suffixResolve(pathParts, normalizedFileList, allFileList, index);
 }
-/** Ruby: require / require_relative. */
-export function resolveRubyImport(rawImportPath, _filePath, ctx) {
-    const resolved = resolveRubyImportInternal(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ctx.index);
-    return resolved ? { kind: 'files', files: [resolved] } : null;
-}

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

@@ -1,8 +1,9 @@
 /**
- * Rust module import resolution.
- * Handles crate::, super::, self:: prefix paths and :: separators.
+ * Rust module import resolution — internal helpers.
+ *
+ * Strategy lives in configs/rust.ts.
+ * This file contains shared helpers used by the strategy and standard.ts.
  */
-import type { ImportResult, ResolveCtx } from './types.js';
 /**
  * Resolve Rust use-path to a file (low-level helper).
  * Handles crate::, super::, self:: prefixes and :: path separators.
@@ -14,5 +15,3 @@ export declare function resolveRustImportInternal(currentFile: string, importPat
  * (last segment might be a symbol name, not a module).
  */
 export declare function tryRustModulePath(modulePath: string, allFiles: Set<string>): string | null;
-/** Rust: expand grouped imports: use {crate::a, crate::b} and use crate::models::{User, Repo}. */
-export declare function resolveRustImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;

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

@@ -1,9 +1,9 @@
 /**
- * Rust module import resolution.
- * Handles crate::, super::, self:: prefix paths and :: separators.
+ * Rust module import resolution — internal helpers.
+ *
+ * Strategy lives in configs/rust.ts.
+ * This file contains shared helpers used by the strategy and standard.ts.
  */
-import { SupportedLanguages } from '../../../_shared/index.js';
-import { resolveStandard } from './standard.js';
 /**
  * Resolve Rust use-path to a file (low-level helper).
  * Handles crate::, super::, self:: prefixes and :: path separators.
@@ -73,46 +73,3 @@ export function tryRustModulePath(modulePath, allFiles) {
     }
     return null;
 }
-/** Rust: expand grouped imports: use {crate::a, crate::b} and use crate::models::{User, Repo}. */
-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 resolved = [];
-        for (const part of parts) {
-            const r = resolveRustImportInternal(filePath, part, ctx.allFilePaths);
-            if (r)
-                resolved.push(r);
-        }
-        return resolved.length > 0 ? { kind: 'files', files: resolved } : null;
-    }
-    // Scoped grouped: use crate::models::{User, Repo}
-    const braceIdx = rawImportPath.indexOf('::{');
-    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 resolved = [];
-        for (const item of items) {
-            // Handle `use crate::models::{User, Repo as R}` — strip alias for resolution
-            const itemName = item.includes(' as ') ? item.split(' as ')[0].trim() : item;
-            const r = resolveRustImportInternal(filePath, `${pathPrefix}::${itemName}`, ctx.allFilePaths);
-            if (r)
-                resolved.push(r);
-        }
-        if (resolved.length > 0)
-            return { kind: 'files', files: resolved };
-        // Fallback: resolve the prefix path itself (e.g. crate::models -> models.rs)
-        const prefixResult = resolveRustImportInternal(filePath, pathPrefix, ctx.allFilePaths);
-        if (prefixResult)
-            return { kind: 'files', files: [prefixResult] };
-    }
-    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.Rust);
-}

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

@@ -5,7 +5,7 @@
  */
 import type { SuffixIndex } from './utils.js';
 import { SupportedLanguages } from '../../../_shared/index.js';
-import type { ImportResult, ImportResolverFn, ResolveCtx } from './types.js';
+import type { ImportResult, ImportResolverStrategy, ResolveCtx } from './types.js';
 import type { TsconfigPaths } from '../language-config.js';
 /** Max entries in the resolve cache. Beyond this, entries are evicted.
  *  100K entries ≈ 15MB — covers the most common import patterns. */
@@ -26,11 +26,5 @@ export declare const resolveImportPath: (currentFile: string, importPath: string
  * Handles relative imports, tsconfig path aliases, and suffix matching.
  */
 export declare function resolveStandard(rawImportPath: string, filePath: string, ctx: ResolveCtx, language: SupportedLanguages): ImportResult;
-/** JavaScript: standard single-file resolution. */
-export declare const resolveJavascriptImport: ImportResolverFn;
-/** TypeScript: standard single-file resolution. */
-export declare const resolveTypescriptImport: ImportResolverFn;
-/** C: standard single-file resolution for #include directives. */
-export declare const resolveCImport: ImportResolverFn;
-/** C++: standard single-file resolution for #include directives. */
-export declare const resolveCppImport: ImportResolverFn;
+/** Create a reusable standard-resolution strategy for a given language. */
+export declare function createStandardStrategy(language: SupportedLanguages): ImportResolverStrategy;

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

@@ -133,11 +133,10 @@ export function resolveStandard(rawImportPath, filePath, ctx, language) {
     const resolvedPath = resolveImportPath(filePath, rawImportPath, ctx.allFilePaths, ctx.allFileList, ctx.normalizedFileList, ctx.resolveCache, language, ctx.configs.tsconfigPaths, ctx.index);
     return resolvedPath ? { kind: 'files', files: [resolvedPath] } : null;
 }
-/** JavaScript: standard single-file resolution. */
-export const resolveJavascriptImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.JavaScript);
-/** TypeScript: standard single-file resolution. */
-export const resolveTypescriptImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.TypeScript);
-/** C: standard single-file resolution for #include directives. */
-export const resolveCImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.C);
-/** C++: standard single-file resolution for #include directives. */
-export const resolveCppImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.CPlusPlus);
+// ============================================================================
+// Strategy factory — composable hook for ImportResolutionConfig
+// ============================================================================
+/** Create a reusable standard-resolution strategy for a given language. */
+export function createStandardStrategy(language) {
+    return (raw, fp, ctx) => resolveStandard(raw, fp, ctx, language);
+}

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

@@ -6,6 +6,7 @@
 import type { TsconfigPaths, GoModuleConfig, CSharpProjectConfig, ComposerConfig } from '../language-config.js';
 import type { SwiftPackageConfig } from '../language-config.js';
 import type { SuffixIndex } from './utils.js';
+import type { SupportedLanguages } from '../../../_shared/index.js';
 /**
  * Result of resolving an import via language-specific dispatch.
  * - 'files': resolved to one or more files -> add to ImportMap
@@ -42,3 +43,26 @@ export interface ResolveCtx extends ImportResolutionContext {
 }
 /** Per-language import resolver -- function alias matching ExportChecker/CallRouter pattern. */
 export type ImportResolverFn = (rawImportPath: string, filePath: string, resolveCtx: ResolveCtx) => ImportResult;
+/**
+ * A single import resolution strategy — one step in a composable chain.
+ * Same signature as ImportResolverFn. Returns null to let the next strategy
+ * in the chain try; returns a result (even with empty files) to stop the chain.
+ */
+export type ImportResolverStrategy = ImportResolverFn;
+/**
+ * Declarative config for composable import resolution — mirrors the
+ * MethodExtractionConfig / CallExtractionConfig pattern.
+ *
+ * Each language declares an ordered list of strategies to try.
+ * The factory (`createImportResolver`) chains them: first non-null result wins.
+ */
+export interface ImportResolutionConfig {
+    /**
+     * Documentation-only metadata identifying which language this config serves.
+     * **Not used by `createImportResolver`** — the factory only iterates `strategies`.
+     * Useful for logging, debugging, and compile-time exhaustiveness checks when
+     * mapping `SupportedLanguages → ImportResolutionConfig` in language providers.
+     */
+    readonly language: SupportedLanguages;
+    readonly strategies: readonly ImportResolverStrategy[];
+}

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

@@ -11,10 +11,12 @@
 import type { SupportedLanguages, MroStrategy } from '../../_shared/index.js';
 import type { LanguageTypeConfig } from './type-extractors/types.js';
 import type { CallRouter } from './call-routing.js';
+import type { CallExtractor } from './call-types.js';
 import type { ClassExtractor } from './class-types.js';
 import type { ExportChecker } from './export-detection.js';
 import type { FieldExtractor } from './field-extractor.js';
 import type { MethodExtractor } from './method-types.js';
+import type { VariableExtractor } from './variable-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';
@@ -119,6 +121,12 @@ interface LanguageProviderConfig {
     /** MRO strategy for multiple inheritance resolution.
      *  Default: 'first-wins'. */
     readonly mroStrategy?: MroStrategy;
+    /** Call extractor for extracting call site information (calledName, callForm,
+     *  receiverName, argCount, mixed chains) from @call / @call.name captures.
+     *  Produced by createCallExtractor() with a per-language CallExtractionConfig.
+     *  Default: undefined — if unset, no calls are extracted for this language.
+     *  All tree-sitter providers MUST supply this. */
+    readonly callExtractor?: CallExtractor;
     /** Field extractor for extracting field/property definitions from class/struct
      *  declarations. Produces FieldInfo[] with name, type, visibility, static,
      *  readonly metadata. Default: undefined (no field extraction). */
@@ -127,6 +135,10 @@ interface LanguageProviderConfig {
      *  declarations. Produces MethodInfo[] with name, parameters, visibility, isAbstract,
      *  isFinal, annotations metadata. Default: undefined (no method extraction). */
     readonly methodExtractor?: MethodExtractor;
+    /** Variable extractor for extracting metadata from module/file-scoped variable,
+     *  constant, and static declarations. Produces VariableInfo with type, visibility,
+     *  isConst, isStatic, isMutable metadata. Default: undefined (no variable extraction). */
+    readonly variableExtractor?: VariableExtractor;
     /** Class/type extractor for deriving canonical qualified names for class-like symbols.
      *  Uses the same provider-driven strategy pattern as method/field extraction so
      *  namespace/package/module rules stay language-specific. */

package/dist/core/ingestion/languages/c-cpp.js

@@ -9,10 +9,12 @@
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { cClassConfig, cppClassConfig } from '../class-extractors/configs/c-cpp.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as cCppConfig } from '../type-extractors/c-cpp.js';
 import { cCppExportChecker } from '../export-detection.js';
-import { resolveCImport, resolveCppImport } from '../import-resolvers/standard.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { cImportConfig, cppImportConfig } from '../import-resolvers/configs/c-cpp.js';
 import { C_QUERIES, CPP_QUERIES } from '../tree-sitter-queries.js';
 /**
  * Node types for standard function declarations that need C/C++ declarator handling.
@@ -29,6 +31,10 @@ import { createFieldExtractor } from '../field-extractors/generic.js';
 import { cConfig as cFieldConfig, cppConfig as cppFieldConfig, } from '../field-extractors/configs/c-cpp.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { cMethodConfig, cppMethodConfig } from '../method-extractors/configs/c-cpp.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { cVariableConfig, cppVariableConfig } from '../variable-extractors/configs/c-cpp.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { cCallConfig, cppCallConfig } from '../call-extractors/configs/c-cpp.js';
 const C_BUILT_INS = new Set([
     'printf',
     'fprintf',
@@ -135,15 +141,8 @@ const C_BUILT_INS = new Set([
     'get',
     'put',
 ]);
-const cClassExtractor = createClassExtractor({
-    language: SupportedLanguages.C,
-    typeDeclarationNodes: ['struct_specifier', 'enum_specifier'],
-});
-const cppClassExtractor = createClassExtractor({
-    language: SupportedLanguages.CPlusPlus,
-    typeDeclarationNodes: ['class_specifier', 'struct_specifier', 'enum_specifier'],
-    ancestorScopeNodeTypes: ['namespace_definition', 'class_specifier', 'struct_specifier'],
-});
+const cClassExtractor = createClassExtractor(cClassConfig);
+const cppClassExtractor = createClassExtractor(cppClassConfig);
 /**
  * C/C++ function name extraction — unwraps pointer_declarator / reference_declarator /
  * function_declarator / qualified_identifier chains to find the actual function name.
@@ -292,13 +291,15 @@ export const cProvider = defineLanguage({
     treeSitterQueries: C_QUERIES,
     typeConfig: cCppConfig,
     exportChecker: cCppExportChecker,
-    importResolver: resolveCImport,
+    importResolver: createImportResolver(cImportConfig),
     importSemantics: 'wildcard-transitive',
+    callExtractor: createCallExtractor(cCallConfig),
     fieldExtractor: createFieldExtractor(cFieldConfig),
     methodExtractor: createMethodExtractor({
         ...cMethodConfig,
         extractFunctionName: cCppExtractFunctionName,
     }),
+    variableExtractor: createVariableExtractor(cVariableConfig),
     classExtractor: cClassExtractor,
     labelOverride: cppLabelOverride,
     builtInNames: C_BUILT_INS,
@@ -309,14 +310,16 @@ export const cppProvider = defineLanguage({
     treeSitterQueries: CPP_QUERIES,
     typeConfig: cCppConfig,
     exportChecker: cCppExportChecker,
-    importResolver: resolveCppImport,
+    importResolver: createImportResolver(cppImportConfig),
     importSemantics: 'wildcard-transitive',
     mroStrategy: 'leftmost-base',
+    callExtractor: createCallExtractor(cppCallConfig),
     fieldExtractor: createFieldExtractor(cppFieldConfig),
     methodExtractor: createMethodExtractor({
         ...cppMethodConfig,
         extractFunctionName: cCppExtractFunctionName,
     }),
+    variableExtractor: createVariableExtractor(cppVariableConfig),
     classExtractor: cppClassExtractor,
     labelOverride: cppLabelOverride,
     builtInNames: C_BUILT_INS,

package/dist/core/ingestion/languages/csharp.js

@@ -7,16 +7,22 @@
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { csharpClassConfig } from '../class-extractors/configs/csharp.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as csharpConfig } from '../type-extractors/csharp.js';
 import { csharpExportChecker } from '../export-detection.js';
-import { resolveCSharpImport } from '../import-resolvers/csharp.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { csharpImportConfig } from '../import-resolvers/configs/csharp.js';
 import { extractCSharpNamedBindings } from '../named-bindings/csharp.js';
 import { CSHARP_QUERIES } from '../tree-sitter-queries.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { csharpCallConfig } from '../call-extractors/configs/csharp.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { csharpConfig as csharpFieldConfig } from '../field-extractors/configs/csharp.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { csharpMethodConfig } from '../method-extractors/configs/csharp.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { csharpVariableConfig } from '../variable-extractors/configs/csharp.js';
 const BUILT_INS = new Set([
     'Console',
     'WriteLine',
@@ -117,30 +123,14 @@ export const csharpProvider = defineLanguage({
     treeSitterQueries: CSHARP_QUERIES,
     typeConfig: csharpConfig,
     exportChecker: csharpExportChecker,
-    importResolver: resolveCSharpImport,
+    importResolver: createImportResolver(csharpImportConfig),
     namedBindingExtractor: extractCSharpNamedBindings,
     interfaceNamePattern: /^I[A-Z]/,
     mroStrategy: 'implements-split',
+    callExtractor: createCallExtractor(csharpCallConfig),
     fieldExtractor: createFieldExtractor(csharpFieldConfig),
     methodExtractor: createMethodExtractor(csharpMethodConfig),
-    classExtractor: createClassExtractor({
-        language: SupportedLanguages.CSharp,
-        typeDeclarationNodes: [
-            'class_declaration',
-            'interface_declaration',
-            'struct_declaration',
-            'enum_declaration',
-            'record_declaration',
-        ],
-        fileScopeNodeTypes: ['file_scoped_namespace_declaration'],
-        ancestorScopeNodeTypes: [
-            'namespace_declaration',
-            'class_declaration',
-            'interface_declaration',
-            'struct_declaration',
-            'enum_declaration',
-            'record_declaration',
-        ],
-    }),
+    variableExtractor: createVariableExtractor(csharpVariableConfig),
+    classExtractor: createClassExtractor(csharpClassConfig),
     builtInNames: BUILT_INS,
 });

package/dist/core/ingestion/languages/dart.js

@@ -12,15 +12,21 @@
 import { FUNCTION_NODE_TYPES } from '../utils/ast-helpers.js';
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { dartClassConfig } from '../class-extractors/configs/dart.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as dartConfig } from '../type-extractors/dart.js';
 import { dartExportChecker } from '../export-detection.js';
-import { resolveDartImport } from '../import-resolvers/dart.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { dartImportConfig } from '../import-resolvers/configs/dart.js';
 import { DART_QUERIES } from '../tree-sitter-queries.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { dartConfig as dartFieldConfig } from '../field-extractors/configs/dart.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { dartMethodConfig } from '../method-extractors/configs/dart.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { dartVariableConfig } from '../variable-extractors/configs/dart.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { dartCallConfig } from '../call-extractors/configs/dart.js';
 /**
  * Resolve the enclosing function from a `function_body` node by looking at its
  * previous sibling.  In Dart's tree-sitter grammar, function_signature and
@@ -82,15 +88,13 @@ export const dartProvider = defineLanguage({
     treeSitterQueries: DART_QUERIES,
     typeConfig: dartConfig,
     exportChecker: dartExportChecker,
-    importResolver: resolveDartImport,
+    importResolver: createImportResolver(dartImportConfig),
     importSemantics: 'wildcard-leaf',
+    callExtractor: createCallExtractor(dartCallConfig),
     fieldExtractor: createFieldExtractor(dartFieldConfig),
     methodExtractor: createMethodExtractor(dartMethodConfig),
-    classExtractor: createClassExtractor({
-        language: SupportedLanguages.Dart,
-        typeDeclarationNodes: ['class_definition', 'extension_declaration', 'enum_declaration'],
-        ancestorScopeNodeTypes: ['class_definition', 'extension_declaration', 'enum_declaration'],
-    }),
+    variableExtractor: createVariableExtractor(dartVariableConfig),
+    classExtractor: createClassExtractor(dartClassConfig),
     enclosingFunctionFinder: dartEnclosingFunctionFinder,
     builtInNames: BUILT_INS,
 });

package/dist/core/ingestion/languages/go.js

@@ -10,41 +10,32 @@
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { goClassConfig } from '../class-extractors/configs/go.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as goConfig } from '../type-extractors/go.js';
 import { goExportChecker } from '../export-detection.js';
-import { resolveGoImport } from '../import-resolvers/go.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { goImportConfig } from '../import-resolvers/configs/go.js';
 import { GO_QUERIES } from '../tree-sitter-queries.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { goConfig as goFieldConfig } from '../field-extractors/configs/go.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { goMethodConfig } from '../method-extractors/configs/go.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { goVariableConfig } from '../variable-extractors/configs/go.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { goCallConfig } from '../call-extractors/configs/go.js';
 export const goProvider = defineLanguage({
     id: SupportedLanguages.Go,
     extensions: ['.go'],
     treeSitterQueries: GO_QUERIES,
     typeConfig: goConfig,
     exportChecker: goExportChecker,
-    importResolver: resolveGoImport,
+    importResolver: createImportResolver(goImportConfig),
     importSemantics: 'wildcard-leaf',
+    callExtractor: createCallExtractor(goCallConfig),
     fieldExtractor: createFieldExtractor(goFieldConfig),
     methodExtractor: createMethodExtractor(goMethodConfig),
-    classExtractor: createClassExtractor({
-        language: SupportedLanguages.Go,
-        typeDeclarationNodes: ['type_declaration'],
-        fileScopeNodeTypes: ['package_clause'],
-        extractName(node) {
-            const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
-            return typeSpec?.childForFieldName('name')?.text;
-        },
-        extractType(node) {
-            const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
-            const typeNode = typeSpec?.childForFieldName('type');
-            if (typeNode?.type === 'struct_type')
-                return 'Struct';
-            if (typeNode?.type === 'interface_type')
-                return 'Interface';
-            return undefined;
-        },
-    }),
+    variableExtractor: createVariableExtractor(goVariableConfig),
+    classExtractor: createClassExtractor(goClassConfig),
 });

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

@@ -8,42 +8,35 @@
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { javaClassConfig } from '../class-extractors/configs/jvm.js';
 import { defineLanguage } from '../language-provider.js';
 import { javaTypeConfig } from '../type-extractors/jvm.js';
 import { javaExportChecker } from '../export-detection.js';
-import { resolveJavaImport } from '../import-resolvers/jvm.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { javaImportConfig } from '../import-resolvers/configs/jvm.js';
 import { extractJavaNamedBindings } from '../named-bindings/java.js';
 import { JAVA_QUERIES } from '../tree-sitter-queries.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { javaCallConfig } from '../call-extractors/configs/jvm.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { javaConfig } from '../field-extractors/configs/jvm.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { javaMethodConfig } from '../method-extractors/configs/jvm.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { javaVariableConfig } from '../variable-extractors/configs/jvm.js';
 export const javaProvider = defineLanguage({
     id: SupportedLanguages.Java,
     extensions: ['.java'],
     treeSitterQueries: JAVA_QUERIES,
     typeConfig: javaTypeConfig,
     exportChecker: javaExportChecker,
-    importResolver: resolveJavaImport,
+    importResolver: createImportResolver(javaImportConfig),
     namedBindingExtractor: extractJavaNamedBindings,
     interfaceNamePattern: /^I[A-Z]/,
     mroStrategy: 'implements-split',
+    callExtractor: createCallExtractor(javaCallConfig),
     fieldExtractor: createFieldExtractor(javaConfig),
     methodExtractor: createMethodExtractor(javaMethodConfig),
-    classExtractor: createClassExtractor({
-        language: SupportedLanguages.Java,
-        typeDeclarationNodes: [
-            'class_declaration',
-            'interface_declaration',
-            'enum_declaration',
-            'record_declaration',
-        ],
-        fileScopeNodeTypes: ['package_declaration'],
-        ancestorScopeNodeTypes: [
-            'class_declaration',
-            'interface_declaration',
-            'enum_declaration',
-            'record_declaration',
-        ],
-    }),
+    variableExtractor: createVariableExtractor(javaVariableConfig),
+    classExtractor: createClassExtractor(javaClassConfig),
 });

package/dist/core/ingestion/languages/kotlin.js

@@ -8,17 +8,23 @@
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { kotlinClassConfig } from '../class-extractors/configs/jvm.js';
 import { defineLanguage } from '../language-provider.js';
 import { kotlinTypeConfig } from '../type-extractors/jvm.js';
 import { kotlinExportChecker } from '../export-detection.js';
-import { resolveKotlinImport } from '../import-resolvers/jvm.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { kotlinImportConfig } from '../import-resolvers/configs/jvm.js';
 import { extractKotlinNamedBindings } from '../named-bindings/kotlin.js';
 import { appendKotlinWildcard } from '../import-resolvers/jvm.js';
 import { KOTLIN_QUERIES } from '../tree-sitter-queries.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { kotlinCallConfig } from '../call-extractors/configs/jvm.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { kotlinConfig } from '../field-extractors/configs/jvm.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { kotlinMethodConfig } from '../method-extractors/configs/jvm.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { kotlinVariableConfig } from '../variable-extractors/configs/jvm.js';
 /** Check if a Kotlin function_declaration capture is inside a class_body (i.e., a method).
  *  Kotlin grammar uses function_declaration for both top-level functions and class methods.
  *  Returns true when the captured definition node has a class_body ancestor. */
@@ -95,23 +101,15 @@ export const kotlinProvider = defineLanguage({
     treeSitterQueries: KOTLIN_QUERIES,
     typeConfig: kotlinTypeConfig,
     exportChecker: kotlinExportChecker,
-    importResolver: resolveKotlinImport,
+    importResolver: createImportResolver(kotlinImportConfig),
     namedBindingExtractor: extractKotlinNamedBindings,
     importPathPreprocessor: appendKotlinWildcard,
     mroStrategy: 'implements-split',
+    callExtractor: createCallExtractor(kotlinCallConfig),
     fieldExtractor: createFieldExtractor(kotlinConfig),
     methodExtractor: createMethodExtractor(kotlinMethodConfig),
-    classExtractor: createClassExtractor({
-        language: SupportedLanguages.Kotlin,
-        typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
-        fileScopeNodeTypes: ['package_header'],
-        ancestorScopeNodeTypes: ['class_declaration', 'object_declaration', 'companion_object'],
-        extractType(node) {
-            if (node.type !== 'class_declaration')
-                return undefined;
-            return node.children.some((child) => child?.text === 'interface') ? 'Interface' : 'Class';
-        },
-    }),
+    variableExtractor: createVariableExtractor(kotlinVariableConfig),
+    classExtractor: createClassExtractor(kotlinClassConfig),
     builtInNames: BUILT_INS,
     labelOverride: (functionNode, defaultLabel) => {
         if (defaultLabel !== 'Function')