@codragraph/cli 1.6.2

package/dist/core/ingestion/languages/csharp/scope-resolver.js

@@ -0,0 +1,63 @@
+/**
+ * C# `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
+ * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
+ *
+ * Second migration after Python — see `pythonScopeResolver` for the
+ * canonical shape.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { csharpProvider } from '../csharp.js';
+import { csharpArityCompatibility, csharpMergeBindings, resolveCsharpImportTarget, } from './index.js';
+import { populateCsharpNamespaceSiblings } from './namespace-siblings.js';
+import { unwrapCsharpCollectionAccessor } from './accessor-unwrap.js';
+const csharpScopeResolver = {
+    language: SupportedLanguages.CSharp,
+    languageProvider: csharpProvider,
+    importEdgeReason: 'csharp-scope: using',
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
+        const ws = { fromFile, allFilePaths };
+        // `WorkspaceIndex` is an opaque `unknown` placeholder in the
+        // shared contract, so `ws` passes structurally without a cast.
+        return resolveCsharpImportTarget({ kind: 'namespace', localName: '_', importedName: '_', targetRaw }, ws);
+    },
+    // C# shadowing: local > using > using static. The per-scope id is
+    // unused by the C# implementation (shadowing is computed purely
+    // from the binding tier), so we don't need to synthesize a Scope.
+    mergeBindings: (existing, incoming) => [...csharpMergeBindings([...existing, ...incoming])],
+    // Adapter: csharpArityCompatibility uses (def, callsite); the
+    // contract is (callsite, def).
+    arityCompatibility: (callsite, def) => csharpArityCompatibility(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+    populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    // C# uses `base` for super-class dispatch, not `super`. Match as a
+    // plain identifier (no `()` call like Python's `super(...)`) — `base`
+    // is a keyword-like receiver, not a callable.
+    isSuperReceiver: (text) => text.trim() === 'base',
+    // Same-namespace cross-file visibility — C# makes every type
+    // declared in `namespace X` visible to other files declaring the
+    // same namespace, without any `using` directive. See
+    // `namespace-siblings.ts` for the implementation.
+    populateNamespaceSiblings: populateCsharpNamespaceSiblings,
+    // C# is statically typed — type information is reliable. Field-
+    // fallback heuristic stays off (the type-binding layer already
+    // produces precise owner types); return-type propagation on is fine
+    // since signatures are authoritative.
+    fieldFallbackOnMethodLookup: false,
+    propagatesReturnTypesAcrossImports: true,
+    // `data.Values` / `data.Keys` on Dictionary-like receivers unwrap
+    // to the value / key element type. Other languages use method-call
+    // syntax for the same access and leave this hook undefined.
+    unwrapCollectionAccessor: unwrapCsharpCollectionAccessor,
+    // C# matches legacy DAG by collapsing member-call CALLS edges to
+    // `(caller, target)` — multiple `g.Greet(...)` sites from Main
+    // yield ONE edge, not one per site.
+    collapseMemberCallsByCallerTarget: true,
+    // C# hoists method return-type bindings to the enclosing Module
+    // scope so `propagateImportedReturnTypes` can mirror them across
+    // files. The compound-receiver walker needs to walk up from the
+    // class scope to find them; see the contract field for rationale.
+    hoistTypeBindingsToModule: true,
+};
+export { csharpScopeResolver };

package/dist/core/ingestion/languages/csharp/simple-hooks.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Trivial / no-op-ish hooks for the C# provider. Kept together because
+ * each is a few lines and they share a common theme: they make the
+ * provider's choice explicit rather than relying on "absence == default"
+ * so reviewers don't have to re-derive the analysis.
+ */
+import type { CaptureMatch, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef } from '../../../../_shared/index.js';
+/** C# has block scope, but the central extractor's "innermost enclosing
+ *  scope" default already handles it correctly: class-body declarations
+ *  attach to the innermost Class scope, method-body declarations attach
+ *  to the innermost Function scope, and namespace-body declarations
+ *  attach to the innermost Namespace scope (which the scope query emits
+ *  for both `namespace X { }` and `namespace X;` forms).
+ *
+ *  Exception: **method return-type bindings** (`@type-binding.return`)
+ *  must hoist all the way to the Module scope. The default auto-hoist
+ *  in the central extractor only promotes one level (Function → its
+ *  parent). For C# methods the parent is always a Class, so without
+ *  this override the return binding gets stuck at the Class scope,
+ *  where it's invisible to:
+ *    - chain-follow's parent-chain walk in `followChainPostFinalize`
+ *      (tests: `var u = GetUser(); u.Save()` single-file);
+ *    - cross-file `propagateImportedReturnTypes`, which reads only
+ *      `sourceModule.typeBindings`.
+ *  Walking to Module restores both paths. */
+export declare function csharpBindingScopeFor(decl: CaptureMatch, innermost: Scope, tree: ScopeTree): ScopeId | null;
+/** `using` inside `namespace X { }` binds to that namespace's scope (its
+ *  types are visible only within that namespace's members). File-level
+ *  `using` delegates to the module default. Class-body `using` is not
+ *  legal C# — defensively handle it by attaching to the class if it
+ *  ever slips through.
+ *
+ *  `global using X;` (C# 10+) at the compilation_unit level is treated
+ *  as a file-scoped using for Unit 2's purposes; cross-file propagation
+ *  will be addressed if Unit 7's parity gate flags it. */
+export declare function csharpImportOwningScope(_imp: ParsedImport, innermost: Scope, _tree: ScopeTree): ScopeId | null;
+/** Look up `this` or `base` in the function scope's type bindings.
+ *
+ *  `this` and `base` are synthesized as type bindings on instance
+ *  methods during capture emission (`receiver-binding.ts`) — `this`
+ *  for every method inside a class/struct/record/interface body, and
+ *  `base` additionally for methods of a class-like type with an
+ *  explicit `base_list`. This hook therefore returns a non-null
+ *  `TypeRef` for instance-method bodies.
+ *
+ *  Returns `null` for:
+ *    - static methods (no `this` synthesized)
+ *    - free functions / module-level code (no enclosing class)
+ *    - non-Function scopes
+ *
+ *  Matches `pythonReceiverBinding`'s shape so the two provider
+ *  wirings stay symmetric. */
+export declare function csharpReceiverBinding(functionScope: Scope): TypeRef | null;

package/dist/core/ingestion/languages/csharp/simple-hooks.js

@@ -0,0 +1,76 @@
+/**
+ * Trivial / no-op-ish hooks for the C# provider. Kept together because
+ * each is a few lines and they share a common theme: they make the
+ * provider's choice explicit rather than relying on "absence == default"
+ * so reviewers don't have to re-derive the analysis.
+ */
+// ─── bindingScopeFor ──────────────────────────────────────────────────────
+/** C# has block scope, but the central extractor's "innermost enclosing
+ *  scope" default already handles it correctly: class-body declarations
+ *  attach to the innermost Class scope, method-body declarations attach
+ *  to the innermost Function scope, and namespace-body declarations
+ *  attach to the innermost Namespace scope (which the scope query emits
+ *  for both `namespace X { }` and `namespace X;` forms).
+ *
+ *  Exception: **method return-type bindings** (`@type-binding.return`)
+ *  must hoist all the way to the Module scope. The default auto-hoist
+ *  in the central extractor only promotes one level (Function → its
+ *  parent). For C# methods the parent is always a Class, so without
+ *  this override the return binding gets stuck at the Class scope,
+ *  where it's invisible to:
+ *    - chain-follow's parent-chain walk in `followChainPostFinalize`
+ *      (tests: `var u = GetUser(); u.Save()` single-file);
+ *    - cross-file `propagateImportedReturnTypes`, which reads only
+ *      `sourceModule.typeBindings`.
+ *  Walking to Module restores both paths. */
+export function csharpBindingScopeFor(decl, innermost, tree) {
+    if (decl['@type-binding.return'] !== undefined) {
+        let cur = innermost;
+        while (cur !== undefined && cur.kind !== 'Module') {
+            const parentId = cur.parent ?? null;
+            if (parentId === null)
+                break;
+            cur = tree.getScope(parentId);
+        }
+        if (cur !== undefined && cur.kind === 'Module')
+            return cur.id;
+    }
+    return null;
+}
+// ─── importOwningScope ────────────────────────────────────────────────────
+/** `using` inside `namespace X { }` binds to that namespace's scope (its
+ *  types are visible only within that namespace's members). File-level
+ *  `using` delegates to the module default. Class-body `using` is not
+ *  legal C# — defensively handle it by attaching to the class if it
+ *  ever slips through.
+ *
+ *  `global using X;` (C# 10+) at the compilation_unit level is treated
+ *  as a file-scoped using for Unit 2's purposes; cross-file propagation
+ *  will be addressed if Unit 7's parity gate flags it. */
+export function csharpImportOwningScope(_imp, innermost, _tree) {
+    if (innermost.kind === 'Namespace' || innermost.kind === 'Class' || innermost.kind === 'Function')
+        return innermost.id;
+    return null;
+}
+// ─── receiverBinding ──────────────────────────────────────────────────────
+/** Look up `this` or `base` in the function scope's type bindings.
+ *
+ *  `this` and `base` are synthesized as type bindings on instance
+ *  methods during capture emission (`receiver-binding.ts`) — `this`
+ *  for every method inside a class/struct/record/interface body, and
+ *  `base` additionally for methods of a class-like type with an
+ *  explicit `base_list`. This hook therefore returns a non-null
+ *  `TypeRef` for instance-method bodies.
+ *
+ *  Returns `null` for:
+ *    - static methods (no `this` synthesized)
+ *    - free functions / module-level code (no enclosing class)
+ *    - non-Function scopes
+ *
+ *  Matches `pythonReceiverBinding`'s shape so the two provider
+ *  wirings stay symmetric. */
+export function csharpReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('this') ?? functionScope.typeBindings.get('base') ?? null;
+}

package/dist/core/ingestion/languages/csharp.d.ts

@@ -0,0 +1,8 @@
+/**
+ * C# language provider.
+ *
+ * C# uses named imports (using directives), modifier-based export detection,
+ * and an implements-split MRO strategy for multiple interface implementation.
+ * Interface names follow the I-prefix convention (e.g., IDisposable).
+ */
+export declare const csharpProvider: import("../language-provider.js").LanguageProvider;

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

@@ -0,0 +1,152 @@
+/**
+ * C# language provider.
+ *
+ * C# uses named imports (using directives), modifier-based export detection,
+ * and an implements-split MRO strategy for multiple interface implementation.
+ * Interface names follow the I-prefix convention (e.g., IDisposable).
+ */
+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 { 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';
+import { emitCsharpScopeCaptures, interpretCsharpImport, interpretCsharpTypeBinding, csharpBindingScopeFor, csharpImportOwningScope, csharpMergeBindings, csharpReceiverBinding, csharpArityCompatibility, resolveCsharpImportTarget, } from './csharp/index.js';
+const BUILT_INS = new Set([
+    'Console',
+    'WriteLine',
+    'ReadLine',
+    'Write',
+    'Task',
+    'Run',
+    'Wait',
+    'WhenAll',
+    'WhenAny',
+    'FromResult',
+    'Delay',
+    'ContinueWith',
+    'ConfigureAwait',
+    'GetAwaiter',
+    'GetResult',
+    'ToString',
+    'GetType',
+    'Equals',
+    'GetHashCode',
+    'ReferenceEquals',
+    'Add',
+    'Remove',
+    'Contains',
+    'Clear',
+    'Count',
+    'Any',
+    'All',
+    'Where',
+    'Select',
+    'SelectMany',
+    'OrderBy',
+    'OrderByDescending',
+    'GroupBy',
+    'First',
+    'FirstOrDefault',
+    'Single',
+    'SingleOrDefault',
+    'Last',
+    'LastOrDefault',
+    'ToList',
+    'ToArray',
+    'ToDictionary',
+    'AsEnumerable',
+    'AsQueryable',
+    'Aggregate',
+    'Sum',
+    'Average',
+    'Min',
+    'Max',
+    'Distinct',
+    'Skip',
+    'Take',
+    'String',
+    'Format',
+    'IsNullOrEmpty',
+    'IsNullOrWhiteSpace',
+    'Concat',
+    'Join',
+    'Trim',
+    'TrimStart',
+    'TrimEnd',
+    'Split',
+    'Replace',
+    'StartsWith',
+    'EndsWith',
+    'Convert',
+    'ToInt32',
+    'ToDouble',
+    'ToBoolean',
+    'ToByte',
+    'Math',
+    'Abs',
+    'Ceiling',
+    'Floor',
+    'Round',
+    'Pow',
+    'Sqrt',
+    'Dispose',
+    'Close',
+    'TryParse',
+    'Parse',
+    'AddRange',
+    'RemoveAt',
+    'RemoveAll',
+    'FindAll',
+    'Exists',
+    'TrueForAll',
+    'ContainsKey',
+    'TryGetValue',
+    'AddOrUpdate',
+    'Throw',
+    'ThrowIfNull',
+]);
+export const csharpProvider = defineLanguage({
+    id: SupportedLanguages.CSharp,
+    extensions: ['.cs'],
+    treeSitterQueries: CSHARP_QUERIES,
+    typeConfig: csharpConfig,
+    exportChecker: csharpExportChecker,
+    importResolver: createImportResolver(csharpImportConfig),
+    namedBindingExtractor: extractCSharpNamedBindings,
+    interfaceNamePattern: /^I[A-Z]/,
+    mroStrategy: 'implements-split',
+    callExtractor: createCallExtractor(csharpCallConfig),
+    fieldExtractor: createFieldExtractor(csharpFieldConfig),
+    methodExtractor: createMethodExtractor(csharpMethodConfig),
+    variableExtractor: createVariableExtractor(csharpVariableConfig),
+    classExtractor: createClassExtractor(csharpClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.CSharp),
+    builtInNames: BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
+    // C# is the second migration after Python. See ./csharp/index.ts for
+    // the full per-hook rationale and the canonical capture vocabulary
+    // in ./csharp/query.ts (CSHARP_SCOPE_QUERY constant).
+    emitScopeCaptures: emitCsharpScopeCaptures,
+    interpretImport: interpretCsharpImport,
+    interpretTypeBinding: interpretCsharpTypeBinding,
+    bindingScopeFor: csharpBindingScopeFor,
+    importOwningScope: csharpImportOwningScope,
+    mergeBindings: (_scope, bindings) => csharpMergeBindings(bindings),
+    receiverBinding: csharpReceiverBinding,
+    arityCompatibility: csharpArityCompatibility,
+    resolveImportTarget: resolveCsharpImportTarget,
+});

package/dist/core/ingestion/languages/dart.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Dart Language Provider
+ *
+ * Dart traits:
+ *   - importSemantics: 'wildcard-leaf' (Dart imports bring everything public into scope)
+ *   - exportChecker: public if no leading underscore
+ *   - Dart SDK imports (dart:*) and external packages are skipped
+ *   - enclosingFunctionFinder: Dart's tree-sitter grammar places function_body
+ *     as a sibling of function_signature/method_signature (not as a child).
+ *     The hook resolves the enclosing function by inspecting the previous sibling.
+ */
+export declare const dartProvider: import("../language-provider.js").LanguageProvider;

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

@@ -0,0 +1,102 @@
+/**
+ * Dart Language Provider
+ *
+ * Dart traits:
+ *   - importSemantics: 'wildcard-leaf' (Dart imports bring everything public into scope)
+ *   - exportChecker: public if no leading underscore
+ *   - Dart SDK imports (dart:*) and external packages are skipped
+ *   - enclosingFunctionFinder: Dart's tree-sitter grammar places function_body
+ *     as a sibling of function_signature/method_signature (not as a child).
+ *     The hook resolves the enclosing function by inspecting the previous sibling.
+ */
+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 { 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
+ * function_body are siblings under program or class_body, unlike most languages
+ * where the function declaration wraps both.
+ *
+ * Extracts the function name inline — Dart uses function_signature and
+ * method_signature (which wraps function_signature) as its FUNCTION_NODE_TYPES.
+ */
+const dartEnclosingFunctionFinder = (node) => {
+    if (node.type !== 'function_body')
+        return null;
+    const prev = node.previousSibling;
+    if (!prev || !FUNCTION_NODE_TYPES.has(prev.type))
+        return null;
+    // method_signature wraps function_signature — unwrap to reach the name
+    let target = prev;
+    let label = 'Function';
+    if (prev.type === 'method_signature') {
+        label = 'Method';
+        for (let i = 0; i < prev.childCount; i++) {
+            const c = prev.child(i);
+            if (c?.type === 'function_signature') {
+                target = c;
+                break;
+            }
+        }
+    }
+    const funcName = target.childForFieldName?.('name')?.text ?? null;
+    return funcName ? { funcName, label } : null;
+};
+const BUILT_INS = new Set([
+    'setState',
+    'mounted',
+    'debugPrint',
+    'runApp',
+    'showDialog',
+    'showModalBottomSheet',
+    'Navigator',
+    'push',
+    'pushNamed',
+    'pushReplacement',
+    'pop',
+    'maybePop',
+    'ScaffoldMessenger',
+    'showSnackBar',
+    'deactivate',
+    'reassemble',
+    'debugDumpApp',
+    'debugDumpRenderTree',
+    'then',
+    'catchError',
+    'whenComplete',
+    'listen',
+]);
+export const dartProvider = defineLanguage({
+    id: SupportedLanguages.Dart,
+    extensions: ['.dart'],
+    treeSitterQueries: DART_QUERIES,
+    typeConfig: dartConfig,
+    exportChecker: dartExportChecker,
+    importResolver: createImportResolver(dartImportConfig),
+    importSemantics: 'wildcard-leaf',
+    callExtractor: createCallExtractor(dartCallConfig),
+    fieldExtractor: createFieldExtractor(dartFieldConfig),
+    methodExtractor: createMethodExtractor(dartMethodConfig),
+    variableExtractor: createVariableExtractor(dartVariableConfig),
+    classExtractor: createClassExtractor(dartClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Dart),
+    enclosingFunctionFinder: dartEnclosingFunctionFinder,
+    builtInNames: BUILT_INS,
+});

package/dist/core/ingestion/languages/go.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Go Language Provider
+ *
+ * Assembles all Go-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Go traits:
+ *   - importSemantics: 'wildcard-leaf' (Go imports entire packages)
+ *   - callRouter: present (Go method calls may need routing)
+ */
+export declare const goProvider: import("../language-provider.js").LanguageProvider;

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

@@ -0,0 +1,44 @@
+/**
+ * Go Language Provider
+ *
+ * Assembles all Go-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Go traits:
+ *   - importSemantics: 'wildcard-leaf' (Go imports entire packages)
+ *   - callRouter: present (Go method calls may need routing)
+ */
+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 { 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: createImportResolver(goImportConfig),
+    importSemantics: 'wildcard-leaf',
+    callExtractor: createCallExtractor(goCallConfig),
+    fieldExtractor: createFieldExtractor(goFieldConfig),
+    methodExtractor: createMethodExtractor(goMethodConfig),
+    variableExtractor: createVariableExtractor(goVariableConfig),
+    classExtractor: createClassExtractor(goClassConfig),
+    heritageExtractor: createHeritageExtractor(goHeritageConfig),
+});

package/dist/core/ingestion/languages/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Language Provider Registry — compile-time exhaustive provider table.
+ *
+ * To add a new language:
+ * 1. Add enum member to SupportedLanguages
+ * 2. Create `languages/<lang>.ts` exporting a LanguageProvider
+ * 3. Add one line to the `providers` table below
+ * 4. Run `tsc --noEmit` to verify
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import type { LanguageProvider } from '../language-provider.js';
+export declare const providers: {
+    javascript: LanguageProvider;
+    typescript: LanguageProvider;
+    python: LanguageProvider;
+    java: LanguageProvider;
+    kotlin: LanguageProvider;
+    go: LanguageProvider;
+    rust: LanguageProvider;
+    csharp: LanguageProvider;
+    c: LanguageProvider;
+    cpp: LanguageProvider;
+    php: LanguageProvider;
+    ruby: LanguageProvider;
+    swift: LanguageProvider;
+    dart: LanguageProvider;
+    vue: LanguageProvider;
+    cobol: LanguageProvider;
+};
+/** Get provider by language enum (always succeeds for SupportedLanguages). */
+export declare function getProvider(language: SupportedLanguages): LanguageProvider;
+/** Look up a language provider from a file path by extension.
+ *  Returns null if the file extension is not recognized. */
+export declare function getProviderForFile(filePath: string): LanguageProvider | null;
+/** Pre-computed list of providers that have implicit import wiring (e.g., Swift).
+ *  Built once at module load — avoids iterating all 13 providers per call. */
+export declare const providersWithImplicitWiring: (LanguageProvider & {
+    implicitImportWirer: NonNullable<LanguageProvider["implicitImportWirer"]>;
+})[];

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

@@ -0,0 +1,64 @@
+/**
+ * Language Provider Registry — compile-time exhaustive provider table.
+ *
+ * To add a new language:
+ * 1. Add enum member to SupportedLanguages
+ * 2. Create `languages/<lang>.ts` exporting a LanguageProvider
+ * 3. Add one line to the `providers` table below
+ * 4. Run `tsc --noEmit` to verify
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { typescriptProvider, javascriptProvider } from './typescript.js';
+import { pythonProvider } from './python.js';
+import { javaProvider } from './java.js';
+import { kotlinProvider } from './kotlin.js';
+import { goProvider } from './go.js';
+import { rustProvider } from './rust.js';
+import { csharpProvider } from './csharp.js';
+import { cProvider, cppProvider } from './c-cpp.js';
+import { phpProvider } from './php.js';
+import { rubyProvider } from './ruby.js';
+import { swiftProvider } from './swift.js';
+import { dartProvider } from './dart.js';
+import { vueProvider } from './vue.js';
+import { cobolProvider } from './cobol.js';
+export const providers = {
+    [SupportedLanguages.JavaScript]: javascriptProvider,
+    [SupportedLanguages.TypeScript]: typescriptProvider,
+    [SupportedLanguages.Python]: pythonProvider,
+    [SupportedLanguages.Java]: javaProvider,
+    [SupportedLanguages.Kotlin]: kotlinProvider,
+    [SupportedLanguages.Go]: goProvider,
+    [SupportedLanguages.Rust]: rustProvider,
+    [SupportedLanguages.CSharp]: csharpProvider,
+    [SupportedLanguages.C]: cProvider,
+    [SupportedLanguages.CPlusPlus]: cppProvider,
+    [SupportedLanguages.PHP]: phpProvider,
+    [SupportedLanguages.Ruby]: rubyProvider,
+    [SupportedLanguages.Swift]: swiftProvider,
+    [SupportedLanguages.Dart]: dartProvider,
+    [SupportedLanguages.Vue]: vueProvider,
+    [SupportedLanguages.Cobol]: cobolProvider,
+};
+/** Get provider by language enum (always succeeds for SupportedLanguages). */
+export function getProvider(language) {
+    return providers[language];
+}
+/** Pre-built extension → provider lookup (built once at module load). */
+const extensionMap = new Map();
+for (const provider of Object.values(providers)) {
+    for (const ext of provider.extensions) {
+        extensionMap.set(ext, provider);
+    }
+}
+/** Look up a language provider from a file path by extension.
+ *  Returns null if the file extension is not recognized. */
+export function getProviderForFile(filePath) {
+    const lastDot = filePath.lastIndexOf('.');
+    const ext = lastDot >= 0 ? filePath.slice(lastDot).toLowerCase() : '';
+    const basename = filePath.slice(filePath.lastIndexOf('/') + 1);
+    return extensionMap.get(ext) ?? extensionMap.get(basename) ?? null;
+}
+/** Pre-computed list of providers that have implicit import wiring (e.g., Swift).
+ *  Built once at module load — avoids iterating all 13 providers per call. */
+export const providersWithImplicitWiring = Object.values(providers).filter((p) => p.implicitImportWirer != null);

package/dist/core/ingestion/languages/java.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Java language provider.
+ *
+ * Java uses named imports, JVM wildcard/member import resolution,
+ * and a 'public' modifier-based export checker. Heritage uses
+ * EXTENDS by default with implements-split MRO for multiple
+ * interface implementation.
+ */
+export declare const javaProvider: import("../language-provider.js").LanguageProvider;