gitnexus 1.6.2-rc.9 → 1.6.2

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,13 @@
 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, DispatchDecision, ImplicitReceiverOverride, ReceiverEnriched } 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 { HeritageExtractor } from './heritage-types.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 +122,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,10 +136,21 @@ 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. */
     readonly classExtractor?: ClassExtractor;
+    /** Heritage extractor for extracting extends/implements/trait-impl relationships
+     *  from tree-sitter @heritage.* captures and call-based heritage (e.g., Ruby
+     *  include/extend/prepend). Produced by createHeritageExtractor() — pass a
+     *  SupportedLanguages value for default behaviour or a full
+     *  HeritageExtractionConfig for languages with custom hooks (Go, Ruby).
+     *  All tree-sitter providers MUST supply this. */
+    readonly heritageExtractor?: HeritageExtractor;
     /** Extract a semantic description for a definition node (e.g., PHP Eloquent
      *  property arrays, relation method descriptions).
      *  Default: undefined (no description extraction). */
@@ -139,6 +159,66 @@ interface LanguageProviderConfig {
      *  When true, the worker extracts routes via the language's route extraction logic.
      *  Default: undefined (no route files). */
     readonly isRouteFile?: (filePath: string) => boolean;
+    /**
+     * DAG stage 3 hook: synthesize an implicit receiver when the call site omits one.
+     *
+     * Runs after shared inference (TypeEnv → constructor-map → class-as-receiver →
+     * mixed-chain). Return an `ImplicitReceiverOverride` to overlay all fields onto
+     * `ReceiverEnriched`; return null to keep current state and proceed to stage 4.
+     *
+     * Constraints: MUST return null when an explicit receiver is already set, at
+     * top-level scope, or for built-in methods. Do not mutate input params.
+     * `hint` is opaque to shared stages; consumed by this language's `selectDispatch`.
+     *
+     * Ruby example: bare `serialize` in `Account#call_serialize` →
+     * `{ callForm: 'member', receiverName: 'self', receiverTypeName: 'Account',
+     *    receiverSource: 'implicit-self', hint: 'instance' }`
+     *
+     * @see call-types.ts § ImplicitReceiverOverride
+     * @see selectDispatch (stage 4, reads the hint)
+     *
+     * Default: undefined (no implicit-receiver inference).
+     */
+    readonly inferImplicitReceiver?: (params: {
+        readonly calledName: string;
+        readonly callForm: 'free' | 'member' | 'constructor' | undefined;
+        readonly receiverName: string | undefined;
+        readonly receiverTypeName: string | undefined;
+        readonly callNode: SyntaxNode;
+        readonly filePath: string;
+    }) => ImplicitReceiverOverride | null;
+    /**
+     * DAG stage 4 hook: decide dispatch strategy (primary path, fallback, MRO view).
+     *
+     * Runs after stage 3. Return a `DispatchDecision` to override shared defaults;
+     * return null to use `defaultDispatchDecision` (constructor→`'constructor'`,
+     * member→`'owner-scoped'`, free→`'free'`). Most languages return null.
+     *
+     * The hook is responsible for its own gating. `ancestryView` only affects
+     * `'ruby-mixin'` strategy. Singleton-ancestry miss NEVER falls through to
+     * file-scoped fallback in stage 5 (enforced in resolveCallTarget).
+     *
+     * Ruby examples:
+     * - `receiverSource='implicit-self', hint='instance'` →
+     *   `{primary: 'owner-scoped', fallback: 'free-arity-narrowed', ancestryView: 'instance'}`
+     * - `receiverSource='class-as-receiver'` →
+     *   `{primary: 'owner-scoped', ancestryView: 'singleton'}` (miss null-routes)
+     * - `receiverSource='implicit-self', hint='singleton'` →
+     *   `{primary: 'owner-scoped', fallback: 'free-arity-narrowed', ancestryView: 'singleton'}`
+     *
+     * @see call-types.ts § DispatchDecision
+     * @see call-processor.ts § defaultDispatchDecision, resolveCallTarget
+     *
+     * Default: undefined (use `defaultDispatchDecision`).
+     */
+    readonly selectDispatch?: (params: {
+        readonly calledName: string;
+        readonly callForm: 'free' | 'member' | 'constructor' | undefined;
+        readonly receiverName: string | undefined;
+        readonly receiverTypeName: string | undefined;
+        readonly receiverSource: ReceiverEnriched['receiverSource'];
+        readonly hint: string | undefined;
+    }) => DispatchDecision | null;
     /** Built-in/stdlib names that should be filtered from the call graph for this language.
      *  Default: undefined (no language-specific filtering). */
     readonly builtInNames?: ReadonlySet<string>;

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,11 @@ 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';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 const C_BUILT_INS = new Set([
     'printf',
     'fprintf',
@@ -135,15 +142,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,14 +292,17 @@ 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,
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.C),
     labelOverride: cppLabelOverride,
     builtInNames: C_BUILT_INS,
 });
@@ -309,15 +312,18 @@ 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,
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.CPlusPlus),
     labelOverride: cppLabelOverride,
     builtInNames: C_BUILT_INS,
 });

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

@@ -7,16 +7,23 @@
  */
 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';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 const BUILT_INS = new Set([
     'Console',
     'WriteLine',
@@ -117,30 +124,15 @@ 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),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.CSharp),
     builtInNames: BUILT_INS,
 });

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

@@ -12,15 +12,22 @@
 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';
+import { createHeritageExtractor } from '../heritage-extractors/generic.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 +89,14 @@ 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),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Dart),
     enclosingFunctionFinder: dartEnclosingFunctionFinder,
     builtInNames: BUILT_INS,
 });

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

@@ -10,41 +10,35 @@
  */
 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';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { goHeritageConfig } from '../heritage-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),
+    heritageExtractor: createHeritageExtractor(goHeritageConfig),
 });

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

@@ -8,42 +8,37 @@
  */
 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';
+import { createHeritageExtractor } from '../heritage-extractors/generic.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),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Java),
 });

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

@@ -8,17 +8,24 @@
  */
 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';
+import { createHeritageExtractor } from '../heritage-extractors/generic.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 +102,16 @@ 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),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Kotlin),
     builtInNames: BUILT_INS,
     labelOverride: (functionNode, defaultLabel) => {
         if (defaultLabel !== 'Function')