gitnexus 1.4.8 → 1.4.9

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"]>;
+})[];

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

@@ -0,0 +1,63 @@
+/**
+ * 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 { 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 { 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.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;

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

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.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 { extractJavaNamedBindings } from '../named-bindings/java.js';
+import { JAVA_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { javaConfig } from '../field-extractors/configs/jvm.js';
+export const javaProvider = defineLanguage({
+    id: SupportedLanguages.Java,
+    extensions: ['.java'],
+    treeSitterQueries: JAVA_QUERIES,
+    typeConfig: javaTypeConfig,
+    exportChecker: javaExportChecker,
+    importResolver: resolveJavaImport,
+    namedBindingExtractor: extractJavaNamedBindings,
+    interfaceNamePattern: /^I[A-Z]/,
+    mroStrategy: 'implements-split',
+    fieldExtractor: createFieldExtractor(javaConfig),
+});

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

@@ -0,0 +1,9 @@
+/**
+ * Kotlin language provider.
+ *
+ * Kotlin uses named imports with JVM wildcard/member resolution and
+ * Java-interop fallback. Default visibility is public (no modifier needed).
+ * Heritage uses EXTENDS by default with implements-split MRO for
+ * multiple interface implementation.
+ */
+export declare const kotlinProvider: import("../language-provider.js").LanguageProvider;

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

@@ -0,0 +1,53 @@
+/**
+ * Kotlin language provider.
+ *
+ * Kotlin uses named imports with JVM wildcard/member resolution and
+ * Java-interop fallback. Default visibility is public (no modifier needed).
+ * Heritage uses EXTENDS by default with implements-split MRO for
+ * multiple interface implementation.
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.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 { extractKotlinNamedBindings } from '../named-bindings/kotlin.js';
+import { appendKotlinWildcard } from '../import-resolvers/jvm.js';
+import { KOTLIN_QUERIES } from '../tree-sitter-queries.js';
+import { isKotlinClassMethod } from '../utils/ast-helpers.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { kotlinConfig } from '../field-extractors/configs/jvm.js';
+const BUILT_INS = new Set([
+    'println', 'print', 'readLine', 'require', 'requireNotNull', 'check', 'assert', 'lazy', 'error',
+    'listOf', 'mapOf', 'setOf', 'mutableListOf', 'mutableMapOf', 'mutableSetOf',
+    'arrayOf', 'sequenceOf', 'also', 'apply', 'run', 'with', 'takeIf', 'takeUnless',
+    'TODO', 'buildString', 'buildList', 'buildMap', 'buildSet',
+    'repeat', 'synchronized',
+    'launch', 'async', 'runBlocking', 'withContext', 'coroutineScope',
+    'supervisorScope', 'delay',
+    'flow', 'flowOf', 'collect', 'emit', 'onEach', 'catch',
+    'buffer', 'conflate', 'distinctUntilChanged',
+    'flatMapLatest', 'flatMapMerge', 'combine',
+    'stateIn', 'shareIn', 'launchIn',
+    'to', 'until', 'downTo', 'step',
+]);
+export const kotlinProvider = defineLanguage({
+    id: SupportedLanguages.Kotlin,
+    extensions: ['.kt', '.kts'],
+    treeSitterQueries: KOTLIN_QUERIES,
+    typeConfig: kotlinTypeConfig,
+    exportChecker: kotlinExportChecker,
+    importResolver: resolveKotlinImport,
+    namedBindingExtractor: extractKotlinNamedBindings,
+    importPathPreprocessor: appendKotlinWildcard,
+    mroStrategy: 'implements-split',
+    fieldExtractor: createFieldExtractor(kotlinConfig),
+    builtInNames: BUILT_INS,
+    labelOverride: (functionNode, defaultLabel) => {
+        if (defaultLabel !== 'Function')
+            return defaultLabel;
+        if (isKotlinClassMethod(functionNode))
+            return 'Method';
+        return defaultLabel;
+    },
+});

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

@@ -0,0 +1,8 @@
+/**
+ * PHP language provider.
+ *
+ * PHP uses named imports (use statements for classes/functions/constants),
+ * and standard export/import resolution. PHP files can use a variety of
+ * extensions from legacy versions through modern PHP 8.
+ */
+export declare const phpProvider: import("../language-provider.js").LanguageProvider;

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

@@ -0,0 +1,145 @@
+/**
+ * PHP language provider.
+ *
+ * PHP uses named imports (use statements for classes/functions/constants),
+ * and standard export/import resolution. PHP files can use a variety of
+ * extensions from legacy versions through modern PHP 8.
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as phpConfig } from '../type-extractors/php.js';
+import { phpExportChecker } from '../export-detection.js';
+import { resolvePhpImport } from '../import-resolvers/php.js';
+import { extractPhpNamedBindings } from '../named-bindings/php.js';
+import { PHP_QUERIES } from '../tree-sitter-queries.js';
+import { findDescendant, extractStringContent } from '../utils/ast-helpers.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { phpConfig as phpFieldConfig } from '../field-extractors/configs/php.js';
+const BUILT_INS = new Set([
+    'echo', 'isset', 'empty', 'unset', 'list', 'array', 'compact', 'extract',
+    'count', 'strlen', 'strpos', 'strrpos', 'substr', 'strtolower', 'strtoupper', 'trim',
+    'ltrim', 'rtrim', 'str_replace', 'str_contains', 'str_starts_with', 'str_ends_with',
+    'sprintf', 'vsprintf', 'printf', 'number_format',
+    'array_map', 'array_filter', 'array_reduce', 'array_push', 'array_pop', 'array_shift',
+    'array_unshift', 'array_slice', 'array_splice', 'array_merge', 'array_keys', 'array_values',
+    'array_key_exists', 'in_array', 'array_search', 'array_unique', 'usort', 'rsort',
+    'json_encode', 'json_decode', 'serialize', 'unserialize',
+    'intval', 'floatval', 'strval', 'boolval', 'is_null', 'is_string', 'is_int', 'is_array',
+    'is_object', 'is_numeric', 'is_bool', 'is_float',
+    'var_dump', 'print_r', 'var_export',
+    'date', 'time', 'strtotime', 'mktime', 'microtime',
+    'file_exists', 'file_get_contents', 'file_put_contents', 'is_file', 'is_dir',
+    'preg_match', 'preg_match_all', 'preg_replace', 'preg_split',
+    'header', 'session_start', 'session_destroy', 'ob_start', 'ob_end_clean', 'ob_get_clean',
+    'dd', 'dump',
+]);
+/** Eloquent model properties whose array values are worth indexing. */
+const ELOQUENT_ARRAY_PROPS = new Set(['fillable', 'casts', 'hidden', 'guarded', 'with', 'appends']);
+/** Eloquent relationship method names. */
+const ELOQUENT_RELATIONS = new Set([
+    'hasMany', 'hasOne', 'belongsTo', 'belongsToMany',
+    'morphTo', 'morphMany', 'morphOne', 'morphToMany', 'morphedByMany',
+    'hasManyThrough', 'hasOneThrough',
+]);
+/**
+ * For a PHP property_declaration node, extract array values as a description string.
+ * Returns null if not an Eloquent model property or no array values found.
+ */
+function extractPhpPropertyDescription(propName, propDeclNode) {
+    if (!ELOQUENT_ARRAY_PROPS.has(propName))
+        return null;
+    const arrayNode = findDescendant(propDeclNode, 'array_creation_expression');
+    if (!arrayNode)
+        return null;
+    const items = [];
+    for (const child of (arrayNode.children ?? [])) {
+        if (child.type !== 'array_element_initializer')
+            continue;
+        const children = child.children ?? [];
+        const arrowIdx = children.findIndex((c) => c.type === '=>');
+        if (arrowIdx !== -1) {
+            const key = extractStringContent(children[arrowIdx - 1]);
+            const val = extractStringContent(children[arrowIdx + 1]);
+            if (key && val)
+                items.push(`${key}:${val}`);
+        }
+        else {
+            const val = extractStringContent(children[0]);
+            if (val)
+                items.push(val);
+        }
+    }
+    return items.length > 0 ? items.join(', ') : null;
+}
+/**
+ * For a PHP method_declaration node, detect if it defines an Eloquent relationship.
+ * Returns description like "hasMany(Post)" or null.
+ */
+function extractEloquentRelationDescription(methodNode) {
+    function findRelationCall(node) {
+        if (node.type === 'member_call_expression') {
+            const children = node.children ?? [];
+            const objectNode = children.find((c) => c.type === 'variable_name' && c.text === '$this');
+            const nameNode = children.find((c) => c.type === 'name');
+            if (objectNode && nameNode && ELOQUENT_RELATIONS.has(nameNode.text))
+                return node;
+        }
+        for (const child of (node.children ?? [])) {
+            const found = findRelationCall(child);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    const callNode = findRelationCall(methodNode);
+    if (!callNode)
+        return null;
+    const relType = callNode.children?.find((c) => c.type === 'name')?.text;
+    const argsNode = callNode.children?.find((c) => c.type === 'arguments');
+    let targetModel = null;
+    if (argsNode) {
+        const firstArg = argsNode.children?.find((c) => c.type === 'argument');
+        if (firstArg) {
+            const classConstant = firstArg.children?.find((c) => c.type === 'class_constant_access_expression');
+            if (classConstant) {
+                targetModel = classConstant.children?.find((c) => c.type === 'name')?.text ?? null;
+            }
+        }
+    }
+    if (relType && targetModel)
+        return `${relType}(${targetModel})`;
+    if (relType)
+        return relType;
+    return null;
+}
+/**
+ * LanguageProvider.descriptionExtractor implementation for PHP.
+ * Extracts Eloquent model property metadata and relationship descriptions.
+ */
+function phpDescriptionExtractor(nodeLabel, nodeName, captureMap) {
+    if (nodeLabel === 'Property' && captureMap['definition.property']) {
+        return extractPhpPropertyDescription(nodeName, captureMap['definition.property']) ?? undefined;
+    }
+    if (nodeLabel === 'Method' && captureMap['definition.method']) {
+        return extractEloquentRelationDescription(captureMap['definition.method']) ?? undefined;
+    }
+    return undefined;
+}
+/** Detect Laravel route files by path convention. */
+function isPhpRouteFile(filePath) {
+    return filePath.endsWith('.php') &&
+        (filePath.includes('/routes/') || filePath.startsWith('routes/'));
+}
+export const phpProvider = defineLanguage({
+    id: SupportedLanguages.PHP,
+    extensions: ['.php', '.phtml', '.php3', '.php4', '.php5', '.php8'],
+    treeSitterQueries: PHP_QUERIES,
+    typeConfig: phpConfig,
+    exportChecker: phpExportChecker,
+    importResolver: resolvePhpImport,
+    namedBindingExtractor: extractPhpNamedBindings,
+    fieldExtractor: createFieldExtractor(phpFieldConfig),
+    descriptionExtractor: phpDescriptionExtractor,
+    isRouteFile: isPhpRouteFile,
+    builtInNames: BUILT_INS,
+});

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

@@ -0,0 +1,12 @@
+/**
+ * Python Language Provider
+ *
+ * Assembles all Python-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Python traits:
+ *   - importSemantics: 'namespace' (Python uses namespace imports, not wildcard)
+ *   - mroStrategy: 'c3' (Python C3 linearization for multiple inheritance)
+ *   - namedBindingExtractor: present (from X import Y)
+ */
+export declare const pythonProvider: import("../language-provider.js").LanguageProvider;

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

@@ -0,0 +1,39 @@
+/**
+ * Python Language Provider
+ *
+ * Assembles all Python-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Python traits:
+ *   - importSemantics: 'namespace' (Python uses namespace imports, not wildcard)
+ *   - mroStrategy: 'c3' (Python C3 linearization for multiple inheritance)
+ *   - namedBindingExtractor: present (from X import Y)
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as pythonConfig } from '../type-extractors/python.js';
+import { pythonExportChecker } from '../export-detection.js';
+import { resolvePythonImport } from '../import-resolvers/python.js';
+import { extractPythonNamedBindings } from '../named-bindings/python.js';
+import { PYTHON_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { pythonConfig as pythonFieldConfig } from '../field-extractors/configs/python.js';
+const BUILT_INS = new Set([
+    'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple',
+    'append', 'extend', 'update',
+    'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr',
+    'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs',
+]);
+export const pythonProvider = defineLanguage({
+    id: SupportedLanguages.Python,
+    extensions: ['.py'],
+    treeSitterQueries: PYTHON_QUERIES,
+    typeConfig: pythonConfig,
+    exportChecker: pythonExportChecker,
+    importResolver: resolvePythonImport,
+    namedBindingExtractor: extractPythonNamedBindings,
+    importSemantics: 'namespace',
+    mroStrategy: 'c3',
+    fieldExtractor: createFieldExtractor(pythonFieldConfig),
+    builtInNames: BUILT_INS,
+});

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

@@ -0,0 +1,9 @@
+/**
+ * Ruby language provider.
+ *
+ * Ruby uses wildcard import semantics (require/require_relative bring
+ * everything into scope). Ruby has SPECIAL call routing via routeRubyCall
+ * to handle require, include/extend (heritage), and attr_accessor/
+ * attr_reader/attr_writer (property definitions) as call expressions.
+ */
+export declare const rubyProvider: import("../language-provider.js").LanguageProvider;

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

@@ -0,0 +1,44 @@
+/**
+ * Ruby language provider.
+ *
+ * Ruby uses wildcard import semantics (require/require_relative bring
+ * everything into scope). Ruby has SPECIAL call routing via routeRubyCall
+ * to handle require, include/extend (heritage), and attr_accessor/
+ * attr_reader/attr_writer (property definitions) as call expressions.
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as rubyConfig } from '../type-extractors/ruby.js';
+import { routeRubyCall } from '../call-routing.js';
+import { rubyExportChecker } from '../export-detection.js';
+import { resolveRubyImport } from '../import-resolvers/ruby.js';
+import { RUBY_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { rubyConfig as rubyFieldConfig } from '../field-extractors/configs/ruby.js';
+const BUILT_INS = new Set([
+    'puts', 'p', 'pp', 'raise', 'fail',
+    'require', 'require_relative', 'load', 'autoload',
+    'include', 'extend', 'prepend',
+    'attr_accessor', 'attr_reader', 'attr_writer',
+    'public', 'private', 'protected', 'module_function',
+    'lambda', 'proc', 'block_given?',
+    'nil?', 'is_a?', 'kind_of?', 'instance_of?', 'respond_to?',
+    'freeze', 'frozen?', 'dup', 'tap', 'yield_self',
+    'each', 'select', 'reject', 'detect', 'collect',
+    'inject', 'flat_map', 'each_with_object', 'each_with_index',
+    'any?', 'all?', 'none?', 'count', 'first', 'last',
+    'sort_by', 'min_by', 'max_by',
+    'group_by', 'partition', 'compact', 'flatten', 'uniq',
+]);
+export const rubyProvider = defineLanguage({
+    id: SupportedLanguages.Ruby,
+    extensions: ['.rb', '.rake', '.gemspec'],
+    treeSitterQueries: RUBY_QUERIES,
+    typeConfig: rubyConfig,
+    exportChecker: rubyExportChecker,
+    importResolver: resolveRubyImport,
+    callRouter: routeRubyCall,
+    importSemantics: 'wildcard',
+    fieldExtractor: createFieldExtractor(rubyFieldConfig),
+    builtInNames: BUILT_INS,
+});

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

@@ -0,0 +1,12 @@
+/**
+ * Rust Language Provider
+ *
+ * Assembles all Rust-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Rust traits:
+ *   - importSemantics: 'named' (Rust has use X::{a, b})
+ *   - mroStrategy: 'qualified-syntax' (Rust uses trait qualification, not MRO)
+ *   - namedBindingExtractor: present (use X::{a, b} extracts named bindings)
+ */
+export declare const rustProvider: import("../language-provider.js").LanguageProvider;

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

@@ -0,0 +1,44 @@
+/**
+ * Rust Language Provider
+ *
+ * Assembles all Rust-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Rust traits:
+ *   - importSemantics: 'named' (Rust has use X::{a, b})
+ *   - mroStrategy: 'qualified-syntax' (Rust uses trait qualification, not MRO)
+ *   - namedBindingExtractor: present (use X::{a, b} extracts named bindings)
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as rustConfig } from '../type-extractors/rust.js';
+import { rustExportChecker } from '../export-detection.js';
+import { resolveRustImport } from '../import-resolvers/rust.js';
+import { extractRustNamedBindings } from '../named-bindings/rust.js';
+import { RUST_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { rustConfig as rustFieldConfig } from '../field-extractors/configs/rust.js';
+const BUILT_INS = new Set([
+    'unwrap', 'expect', 'unwrap_or', 'unwrap_or_else', 'unwrap_or_default',
+    'ok', 'err', 'is_ok', 'is_err', 'map', 'map_err', 'and_then', 'or_else',
+    'clone', 'to_string', 'to_owned', 'into', 'from', 'as_ref', 'as_mut',
+    'iter', 'into_iter', 'collect', 'filter', 'fold', 'for_each',
+    'len', 'is_empty', 'push', 'pop', 'insert', 'remove', 'contains',
+    'format', 'write', 'writeln', 'panic', 'unreachable', 'todo', 'unimplemented',
+    'vec', 'println', 'eprintln', 'dbg',
+    'lock', 'read', 'try_lock',
+    'spawn', 'join', 'sleep',
+    'Some', 'None', 'Ok', 'Err',
+]);
+export const rustProvider = defineLanguage({
+    id: SupportedLanguages.Rust,
+    extensions: ['.rs'],
+    treeSitterQueries: RUST_QUERIES,
+    typeConfig: rustConfig,
+    exportChecker: rustExportChecker,
+    importResolver: resolveRustImport,
+    namedBindingExtractor: extractRustNamedBindings,
+    mroStrategy: 'qualified-syntax',
+    fieldExtractor: createFieldExtractor(rustFieldConfig),
+    builtInNames: BUILT_INS,
+});

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

@@ -0,0 +1,12 @@
+/**
+ * Swift Language Provider
+ *
+ * Assembles all Swift-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Swift traits:
+ *   - importSemantics: 'wildcard' (Swift imports entire modules)
+ *   - heritageDefaultEdge: 'IMPLEMENTS' (protocols are more common than class inheritance)
+ *   - implicitImportWirer: all files in the same SPM target see each other
+ */
+export declare const swiftProvider: import("../language-provider.js").LanguageProvider;