gitnexus 1.4.7 → 1.4.9

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

@@ -0,0 +1,44 @@
+/**
+ * Import resolution types — shared across all per-language resolvers.
+ *
+ * Extracted from import-resolution.ts to co-locate types with their consumers.
+ */
+import type { TsconfigPaths, GoModuleConfig, CSharpProjectConfig, ComposerConfig } from '../language-config.js';
+import type { SwiftPackageConfig } from '../language-config.js';
+import type { SuffixIndex } from './utils.js';
+/**
+ * Result of resolving an import via language-specific dispatch.
+ * - 'files': resolved to one or more files -> add to ImportMap
+ * - 'package': resolved to a directory -> add graph edges + store dirSuffix in PackageMap
+ * - null: no resolution (external dependency, etc.)
+ */
+export type ImportResult = {
+    kind: 'files';
+    files: string[];
+} | {
+    kind: 'package';
+    files: string[];
+    dirSuffix: string;
+} | null;
+/** Bundled language-specific configs loaded once per ingestion run. */
+export interface ImportConfigs {
+    tsconfigPaths: TsconfigPaths | null;
+    goModule: GoModuleConfig | null;
+    composerConfig: ComposerConfig | null;
+    swiftPackageConfig: SwiftPackageConfig | null;
+    csharpConfigs: CSharpProjectConfig[];
+}
+/** Pre-built lookup structures for import resolution. Build once, reuse across chunks. */
+export interface ImportResolutionContext {
+    allFilePaths: Set<string>;
+    allFileList: string[];
+    normalizedFileList: string[];
+    index: SuffixIndex;
+    resolveCache: Map<string, string | null>;
+}
+/** Full context for import resolution: file lookups + language configs. */
+export interface ResolveCtx extends ImportResolutionContext {
+    configs: ImportConfigs;
+}
+/** Per-language import resolver -- function alias matching ExportChecker/CallRouter pattern. */
+export type ImportResolverFn = (rawImportPath: string, filePath: string, resolveCtx: ResolveCtx) => ImportResult;

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

@@ -0,0 +1,6 @@
+/**
+ * Import resolution types — shared across all per-language resolvers.
+ *
+ * Extracted from import-resolution.ts to co-locate types with their consumers.
+ */
+export {};

package/dist/core/ingestion/{resolvers → import-resolvers}/utils.d.ts

@@ -26,6 +26,8 @@ export interface SuffixIndex {
     /** Get all files in a directory suffix */
     getFilesInDir(dirSuffix: string, extension: string): string[];
 }
+/** Sentinel index that returns no results. Used to release memory after import resolution. */
+export declare const EMPTY_INDEX: SuffixIndex;
 export declare function buildSuffixIndex(normalizedFileList: string[], allFileList: string[]): SuffixIndex;
 /**
  * Suffix-based resolution using index. O(1) per lookup instead of O(files).

package/dist/core/ingestion/{resolvers → import-resolvers}/utils.js

@@ -40,6 +40,13 @@ export function tryResolveWithExtensions(basePath, allFiles) {
     }
     return null;
 }
+const FROZEN_EMPTY_ARRAY = Object.freeze([]);
+/** Sentinel index that returns no results. Used to release memory after import resolution. */
+export const EMPTY_INDEX = Object.freeze({
+    get: () => undefined,
+    getInsensitive: () => undefined,
+    getFilesInDir: () => FROZEN_EMPTY_ARRAY,
+});
 export function buildSuffixIndex(normalizedFileList, allFileList) {
     // Map: normalized suffix -> original file path
     const exactMap = new Map();

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

@@ -1,3 +1,4 @@
+import type { ImportConfigs } from './import-resolvers/types.js';
 /** TypeScript path alias config parsed from tsconfig.json */
 export interface TsconfigPaths {
     /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */
@@ -14,6 +15,9 @@ export interface GoModuleConfig {
 export interface ComposerConfig {
     /** Map of namespace prefix -> directory (e.g., "App\\" -> "app/") */
     psr4: Map<string, string>;
+    /** PSR-4 entries sorted by namespace length descending (longest match wins).
+     *  Cached once at config load time to avoid re-sorting on every import. */
+    psr4Sorted?: readonly [string, string][];
 }
 /** C# project config parsed from .csproj files */
 export interface CSharpProjectConfig {
@@ -44,3 +48,5 @@ export declare function loadComposerConfig(repoRoot: string): Promise<ComposerCo
  */
 export declare function loadCSharpProjectConfig(repoRoot: string): Promise<CSharpProjectConfig[]>;
 export declare function loadSwiftPackageConfig(repoRoot: string): Promise<SwiftPackageConfig | null>;
+/** Load all language-specific configs once for an ingestion run. */
+export declare function loadImportConfigs(repoRoot: string): Promise<ImportConfigs>;

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

@@ -165,3 +165,16 @@ export async function loadSwiftPackageConfig(repoRoot) {
     }
     return null;
 }
+// ============================================================================
+// BUNDLED CONFIG LOADER
+// ============================================================================
+/** Load all language-specific configs once for an ingestion run. */
+export async function loadImportConfigs(repoRoot) {
+    return {
+        tsconfigPaths: await loadTsconfigPaths(repoRoot),
+        goModule: await loadGoModulePath(repoRoot),
+        composerConfig: await loadComposerConfig(repoRoot),
+        swiftPackageConfig: await loadSwiftPackageConfig(repoRoot),
+        csharpConfigs: await loadCSharpProjectConfig(repoRoot),
+    };
+}

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

@@ -0,0 +1,121 @@
+/**
+ * Language Provider interface — the complete capability contract for a supported language.
+ *
+ * Each language implements this interface in a single file under `languages/`.
+ * The pipeline accesses all per-language behavior through this interface.
+ *
+ * Design pattern: Strategy pattern with compile-time exhaustiveness.
+ * The providers table in `languages/index.ts` uses `satisfies Record<SupportedLanguages, LanguageProvider>`
+ * so adding a language to the enum without creating a provider is a compiler error.
+ */
+import type { SupportedLanguages } from '../../config/supported-languages.js';
+import type { LanguageTypeConfig } from './type-extractors/types.js';
+import type { CallRouter } from './call-routing.js';
+import type { ExportChecker } from './export-detection.js';
+import type { FieldExtractor } from './field-extractor.js';
+import type { ImportResolverFn } from './import-resolvers/types.js';
+import type { NamedBindingExtractorFn } from './named-bindings/types.js';
+import type { SyntaxNode } from './utils/ast-helpers.js';
+import type { NodeLabel } from '../graph/types.js';
+/** Tree-sitter query captures: capture name → AST node (or undefined if not captured). */
+export type CaptureMap = Record<string, SyntaxNode | undefined>;
+/** MRO strategy for multiple inheritance resolution. */
+export type MroStrategy = 'first-wins' | 'c3' | 'leftmost-base' | 'implements-split' | 'qualified-syntax';
+/** How a language handles imports — determines wildcard synthesis behavior. */
+export type ImportSemantics = 'named' | 'wildcard' | 'namespace';
+/**
+ * Everything a language needs to provide.
+ * Required fields must be explicitly set; optional fields have defaults
+ * applied by defineLanguage().
+ */
+interface LanguageProviderConfig {
+    readonly id: SupportedLanguages;
+    /** File extensions that map to this language (e.g., ['.ts', '.tsx']) */
+    readonly extensions: readonly string[];
+    /** Parse strategy: 'tree-sitter' (default) uses AST parsing via tree-sitter.
+     *  'standalone' means the language has its own regex-based processor and
+     *  should be skipped by the tree-sitter pipeline (e.g., COBOL, Markdown). */
+    readonly parseStrategy?: 'tree-sitter' | 'standalone';
+    /** Tree-sitter query strings for definitions, imports, calls, heritage.
+     *  Required for tree-sitter languages; empty string for standalone processors. */
+    readonly treeSitterQueries: string;
+    /** Type extraction: declarations, initializers, for-loop bindings */
+    readonly typeConfig: LanguageTypeConfig;
+    /** Export detection: is this AST node a public/exported symbol? */
+    readonly exportChecker: ExportChecker;
+    /** Import resolution: resolves raw import path to file system path */
+    readonly importResolver: ImportResolverFn;
+    /** Call routing for languages that express imports/heritage as calls (e.g., Ruby).
+     *  Default: no routing (all calls are normal call expressions). */
+    readonly callRouter?: CallRouter;
+    /** Named binding extraction from import statements.
+     *  Default: undefined (language uses wildcard/whole-module imports). */
+    readonly namedBindingExtractor?: NamedBindingExtractorFn;
+    /** How this language handles imports.
+     *  - 'named': per-symbol imports (JS/TS, Java, C#, Rust, PHP, Kotlin)
+     *  - 'wildcard': whole-module imports, needs synthesis (Go, Ruby, C/C++, Swift)
+     *  - 'namespace': namespace imports, needs moduleAliasMap (Python)
+     *  Default: 'named'. */
+    readonly importSemantics?: ImportSemantics;
+    /** Language-specific transformation of raw import path text before resolution.
+     *  Called after sanitization. E.g., Kotlin appends wildcard suffixes.
+     *  Default: undefined (no preprocessing). */
+    readonly importPathPreprocessor?: (cleaned: string, importNode: SyntaxNode) => string;
+    /** Wire implicit inter-file imports for languages where all files in a module
+     *  see each other (e.g., Swift targets, C header inclusion units).
+     *  Called with only THIS language's files (pre-grouped by the processor).
+     *  Default: undefined (no implicit imports). */
+    readonly implicitImportWirer?: (languageFiles: string[], importMap: ReadonlyMap<string, ReadonlySet<string>>, addImportEdge: (src: string, target: string) => void, projectConfig: unknown) => void;
+    /** Resolve the enclosing function name + label from an AST ancestor node
+     *  that is NOT a standard FUNCTION_NODE_TYPE.  For languages where the
+     *  function body is a sibling of the signature (e.g. Dart: function_body ↔
+     *  function_signature are siblings under program/class_body), the default
+     *  parent walk cannot find the enclosing function.  This hook lets the
+     *  language provider inspect each ancestor and return the resolved result.
+     *  Return null to continue the default walk.
+     *  Default: undefined (standard parent walk only). */
+    readonly enclosingFunctionFinder?: (ancestorNode: SyntaxNode) => {
+        funcName: string;
+        label: NodeLabel;
+    } | null;
+    /** Override the default node label for definition.function captures.
+     *  Return null to skip (C/C++ duplicate), a different label to reclassify
+     *  (e.g., 'Method' for Kotlin), or defaultLabel to keep as-is.
+     *  Default: undefined (standard label assignment). */
+    readonly labelOverride?: (functionNode: SyntaxNode, defaultLabel: NodeLabel) => NodeLabel | null;
+    /** Default edge type when parent symbol is ambiguous (interface vs class).
+     *  Default: 'EXTENDS'. */
+    readonly heritageDefaultEdge?: 'EXTENDS' | 'IMPLEMENTS';
+    /** Regex to detect interface names by convention (e.g., /^I[A-Z]/ for C#/Java).
+     *  When matched, IMPLEMENTS edge is used instead of heritageDefaultEdge. */
+    readonly interfaceNamePattern?: RegExp;
+    /** MRO strategy for multiple inheritance resolution.
+     *  Default: 'first-wins'. */
+    readonly mroStrategy?: MroStrategy;
+    /** 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). */
+    readonly fieldExtractor?: FieldExtractor;
+    /** Extract a semantic description for a definition node (e.g., PHP Eloquent
+     *  property arrays, relation method descriptions).
+     *  Default: undefined (no description extraction). */
+    readonly descriptionExtractor?: (nodeLabel: NodeLabel, nodeName: string, captureMap: CaptureMap) => string | undefined;
+    /** Detect if a file contains framework route definitions (e.g., Laravel routes.php).
+     *  When true, the worker extracts routes via the language's route extraction logic.
+     *  Default: undefined (no route files). */
+    readonly isRouteFile?: (filePath: string) => boolean;
+    /** 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>;
+}
+/** Runtime type — same as LanguageProviderConfig but with defaults guaranteed present. */
+export interface LanguageProvider extends Omit<LanguageProviderConfig, 'importSemantics' | 'heritageDefaultEdge' | 'mroStrategy'> {
+    readonly importSemantics: ImportSemantics;
+    readonly heritageDefaultEdge: 'EXTENDS' | 'IMPLEMENTS';
+    readonly mroStrategy: MroStrategy;
+    /** Check if a name is a built-in/stdlib function that should be filtered from the call graph. */
+    readonly isBuiltInName: (name: string) => boolean;
+}
+/** Define a language provider — required fields must be supplied, optional fields get sensible defaults. */
+export declare function defineLanguage(config: LanguageProviderConfig): LanguageProvider;
+export {};

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

@@ -0,0 +1,24 @@
+/**
+ * Language Provider interface — the complete capability contract for a supported language.
+ *
+ * Each language implements this interface in a single file under `languages/`.
+ * The pipeline accesses all per-language behavior through this interface.
+ *
+ * Design pattern: Strategy pattern with compile-time exhaustiveness.
+ * The providers table in `languages/index.ts` uses `satisfies Record<SupportedLanguages, LanguageProvider>`
+ * so adding a language to the enum without creating a provider is a compiler error.
+ */
+const DEFAULTS = {
+    importSemantics: 'named',
+    heritageDefaultEdge: 'EXTENDS',
+    mroStrategy: 'first-wins',
+};
+/** Define a language provider — required fields must be supplied, optional fields get sensible defaults. */
+export function defineLanguage(config) {
+    const builtIns = config.builtInNames;
+    return {
+        ...DEFAULTS,
+        ...config,
+        isBuiltInName: builtIns ? (name) => builtIns.has(name) : () => false,
+    };
+}

package/dist/core/ingestion/languages/c-cpp.d.ts

@@ -0,0 +1,12 @@
+/**
+ * C and C++ language providers.
+ *
+ * Both languages use wildcard import semantics (headers expose all symbols
+ * via #include). Neither language has named binding extraction.
+ *
+ * C uses 'first-wins' MRO (no inheritance). C++ uses 'leftmost-base' MRO
+ * for its left-to-right multiple inheritance resolution order.
+ */
+import type { LanguageProvider } from '../language-provider.js';
+export declare const cProvider: LanguageProvider;
+export declare const cppProvider: LanguageProvider;

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

@@ -0,0 +1,71 @@
+/**
+ * C and C++ language providers.
+ *
+ * Both languages use wildcard import semantics (headers expose all symbols
+ * via #include). Neither language has named binding extraction.
+ *
+ * C uses 'first-wins' MRO (no inheritance). C++ uses 'leftmost-base' MRO
+ * for its left-to-right multiple inheritance resolution order.
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.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 { C_QUERIES, CPP_QUERIES } from '../tree-sitter-queries.js';
+import { isCppInsideClassOrStruct } from '../utils/ast-helpers.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { cConfig as cFieldConfig, cppConfig as cppFieldConfig } from '../field-extractors/configs/c-cpp.js';
+const C_BUILT_INS = new Set([
+    'printf', 'fprintf', 'sprintf', 'snprintf', 'vprintf', 'vfprintf', 'vsprintf', 'vsnprintf',
+    'scanf', 'fscanf', 'sscanf',
+    'malloc', 'calloc', 'realloc', 'free', 'memcpy', 'memmove', 'memset', 'memcmp',
+    'strlen', 'strcpy', 'strncpy', 'strcat', 'strncat', 'strcmp', 'strncmp', 'strstr', 'strchr', 'strrchr',
+    'atoi', 'atol', 'atof', 'strtol', 'strtoul', 'strtoll', 'strtoull', 'strtod',
+    'sizeof', 'offsetof', 'typeof',
+    'assert', 'abort', 'exit', '_exit',
+    'fopen', 'fclose', 'fread', 'fwrite', 'fseek', 'ftell', 'rewind', 'fflush', 'fgets', 'fputs',
+    'likely', 'unlikely', 'BUG', 'BUG_ON', 'WARN', 'WARN_ON', 'WARN_ONCE',
+    'IS_ERR', 'PTR_ERR', 'ERR_PTR', 'IS_ERR_OR_NULL',
+    'ARRAY_SIZE', 'container_of', 'list_for_each_entry', 'list_for_each_entry_safe',
+    'min', 'max', 'clamp', 'abs', 'swap',
+    'pr_info', 'pr_warn', 'pr_err', 'pr_debug', 'pr_notice', 'pr_crit', 'pr_emerg',
+    'printk', 'dev_info', 'dev_warn', 'dev_err', 'dev_dbg',
+    'GFP_KERNEL', 'GFP_ATOMIC',
+    'spin_lock', 'spin_unlock', 'spin_lock_irqsave', 'spin_unlock_irqrestore',
+    'mutex_lock', 'mutex_unlock', 'mutex_init',
+    'kfree', 'kmalloc', 'kzalloc', 'kcalloc', 'krealloc', 'kvmalloc', 'kvfree',
+    'get', 'put',
+]);
+/** Label override shared by C and C++: skip function_definition captures inside class/struct
+ *  bodies (they're duplicates of definition.method captures). */
+const cppLabelOverride = (functionNode, defaultLabel) => {
+    if (defaultLabel !== 'Function')
+        return defaultLabel;
+    return isCppInsideClassOrStruct(functionNode) ? null : defaultLabel;
+};
+export const cProvider = defineLanguage({
+    id: SupportedLanguages.C,
+    extensions: ['.c'],
+    treeSitterQueries: C_QUERIES,
+    typeConfig: cCppConfig,
+    exportChecker: cCppExportChecker,
+    importResolver: resolveCImport,
+    importSemantics: 'wildcard',
+    fieldExtractor: createFieldExtractor(cFieldConfig),
+    labelOverride: cppLabelOverride,
+    builtInNames: C_BUILT_INS,
+});
+export const cppProvider = defineLanguage({
+    id: SupportedLanguages.CPlusPlus,
+    extensions: ['.cpp', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.hh'],
+    treeSitterQueries: CPP_QUERIES,
+    typeConfig: cCppConfig,
+    exportChecker: cCppExportChecker,
+    importResolver: resolveCppImport,
+    importSemantics: 'wildcard',
+    mroStrategy: 'leftmost-base',
+    fieldExtractor: createFieldExtractor(cppFieldConfig),
+    labelOverride: cppLabelOverride,
+    builtInNames: C_BUILT_INS,
+});

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

@@ -0,0 +1 @@
+export declare const cobolProvider: import("../language-provider.js").LanguageProvider;

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

@@ -0,0 +1,26 @@
+/**
+ * COBOL Language Provider
+ *
+ * Standalone regex-based processor — no tree-sitter grammar.
+ * COBOL files (.cbl, .cob, .cobol, .cpy, .copybook) are detected and
+ * processed by cobol-processor.ts in pipeline Phase 2.6, not by the
+ * tree-sitter pipeline.
+ *
+ * This provider exists to satisfy the SupportedLanguages exhaustiveness
+ * checks and to declare parseStrategy: 'standalone'.
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { defineLanguage } from '../language-provider.js';
+export const cobolProvider = defineLanguage({
+    id: SupportedLanguages.Cobol,
+    parseStrategy: 'standalone',
+    extensions: [], // COBOL files detected by cobol-processor's isCobolFile/isJclFile
+    treeSitterQueries: '',
+    typeConfig: {
+        declarationNodeTypes: new Set(),
+        extractDeclaration: () => null,
+        extractParameter: () => null,
+    },
+    exportChecker: () => false,
+    importResolver: () => 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,49 @@
+/**
+ * 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 '../../../config/supported-languages.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 { extractCSharpNamedBindings } from '../named-bindings/csharp.js';
+import { CSHARP_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { csharpConfig as csharpFieldConfig } from '../field-extractors/configs/csharp.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: resolveCSharpImport,
+    namedBindingExtractor: extractCSharpNamedBindings,
+    interfaceNamePattern: /^I[A-Z]/,
+    mroStrategy: 'implements-split',
+    fieldExtractor: createFieldExtractor(csharpFieldConfig),
+    builtInNames: BUILT_INS,
+});

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

@@ -0,0 +1,12 @@
+/**
+ * Dart Language Provider
+ *
+ * Dart traits:
+ *   - importSemantics: 'wildcard' (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,58 @@
+/**
+ * Dart Language Provider
+ *
+ * Dart traits:
+ *   - importSemantics: 'wildcard' (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, extractFunctionName } from '../utils/ast-helpers.js';
+import { SupportedLanguages } from '../../../config/supported-languages.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 { DART_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { dartConfig as dartFieldConfig } from '../field-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
+ * function_body are siblings under program or class_body, unlike most languages
+ * where the function declaration wraps both.
+ *
+ * Delegates name extraction to the shared `extractFunctionName` which already
+ * handles Dart's function_signature and method_signature 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;
+    const { funcName, label } = extractFunctionName(prev);
+    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: resolveDartImport,
+    importSemantics: 'wildcard',
+    fieldExtractor: createFieldExtractor(dartFieldConfig),
+    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' (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,28 @@
+/**
+ * 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' (Go imports entire packages)
+ *   - callRouter: present (Go method calls may need routing)
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.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 { GO_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { goConfig as goFieldConfig } from '../field-extractors/configs/go.js';
+export const goProvider = defineLanguage({
+    id: SupportedLanguages.Go,
+    extensions: ['.go'],
+    treeSitterQueries: GO_QUERIES,
+    typeConfig: goConfig,
+    exportChecker: goExportChecker,
+    importResolver: resolveGoImport,
+    importSemantics: 'wildcard',
+    fieldExtractor: createFieldExtractor(goFieldConfig),
+});

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

@@ -0,0 +1,38 @@
+/**
+ * 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 '../../../config/supported-languages.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;
+    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"]>;
+})[];