gitnexus 1.4.7 → 1.4.9

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;

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

@@ -0,0 +1,133 @@
+/**
+ * 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
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as swiftConfig } from '../type-extractors/swift.js';
+import { swiftExportChecker } from '../export-detection.js';
+import { resolveSwiftImport } from '../import-resolvers/swift.js';
+import { SWIFT_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { swiftConfig as swiftFieldConfig } from '../field-extractors/configs/swift.js';
+/**
+ * Group Swift files by SPM target for implicit module visibility.
+ * If SwiftPackageConfig is available, use target -> directory mappings.
+ * Otherwise, group all Swift files under a single "default" target
+ * (assumes a single-module Xcode project).
+ */
+function groupSwiftFilesByTarget(swiftFiles, swiftPackageConfig) {
+    // No SPM config -> single target (common for Xcode projects)
+    if (!swiftPackageConfig || swiftPackageConfig.targets.size === 0) {
+        return new Map([['__default__', swiftFiles]]);
+    }
+    // Pre-convert target dirs to normalized prefix format once
+    const targets = [...swiftPackageConfig.targets.entries()].map(([name, dir]) => ({ name, prefix: dir.replace(/\\/g, '/') + '/' }));
+    const groups = new Map();
+    const defaultGroup = [];
+    for (const file of swiftFiles) {
+        const normalized = file.includes('\\') ? file.replace(/\\/g, '/') : file;
+        let assigned = false;
+        for (const { name, prefix } of targets) {
+            const idx = normalized.indexOf(prefix);
+            if (idx === 0 || (idx > 0 && normalized[idx - 1] === '/')) {
+                let group = groups.get(name);
+                if (!group) {
+                    group = [];
+                    groups.set(name, group);
+                }
+                group.push(file);
+                assigned = true;
+                break;
+            }
+        }
+        if (!assigned)
+            defaultGroup.push(file);
+    }
+    if (defaultGroup.length > 0)
+        groups.set('__default__', defaultGroup);
+    return groups;
+}
+/**
+ * Wire implicit inter-file imports for Swift.
+ * All files in the same SPM target see each other (full module visibility).
+ * Two fast paths avoid unnecessary work:
+ *   1. No existing imports for src -> emit all (m-1) edges without Set.has checks
+ *   2. Existing imports present -> skip already-connected pairs
+ */
+function wireSwiftImplicitImports(swiftFiles, importMap, addImportEdge, projectConfig) {
+    const configs = projectConfig;
+    const targetGroups = groupSwiftFilesByTarget(swiftFiles, configs?.swiftPackageConfig ?? null);
+    for (const group of targetGroups.values()) {
+        const m = group.length;
+        if (m <= 1)
+            continue;
+        // All-pairs implicit edges: O(m²) is inherent for full module visibility.
+        for (let i = 0; i < m; i++) {
+            const src = group[i];
+            const existing = importMap.get(src);
+            if (!existing || existing.size === 0) {
+                // Fast path: no prior imports — emit all peers unconditionally
+                for (let j = 0; j < m; j++) {
+                    if (i !== j)
+                        addImportEdge(src, group[j]);
+                }
+            }
+            else {
+                // Dedup path: skip already-connected pairs
+                for (let j = 0; j < m; j++) {
+                    if (i !== j && !existing.has(group[j])) {
+                        addImportEdge(src, group[j]);
+                    }
+                }
+            }
+        }
+    }
+}
+const BUILT_INS = new Set([
+    'print', 'debugPrint', 'dump', 'fatalError', 'precondition', 'preconditionFailure',
+    'assert', 'assertionFailure', 'NSLog',
+    'abs', 'min', 'max', 'zip', 'stride', 'sequence', 'repeatElement',
+    'swap', 'withUnsafePointer', 'withUnsafeMutablePointer', 'withUnsafeBytes',
+    'autoreleasepool', 'unsafeBitCast', 'unsafeDowncast', 'numericCast',
+    'type', 'MemoryLayout',
+    'map', 'flatMap', 'compactMap', 'filter', 'reduce', 'forEach', 'contains',
+    'first', 'last', 'prefix', 'suffix', 'dropFirst', 'dropLast',
+    'sorted', 'reversed', 'enumerated', 'joined', 'split',
+    'append', 'insert', 'remove', 'removeAll', 'removeFirst', 'removeLast',
+    'isEmpty', 'count', 'index', 'startIndex', 'endIndex',
+    'addSubview', 'removeFromSuperview', 'layoutSubviews', 'setNeedsLayout',
+    'layoutIfNeeded', 'setNeedsDisplay', 'invalidateIntrinsicContentSize',
+    'addTarget', 'removeTarget', 'addGestureRecognizer',
+    'addConstraint', 'addConstraints', 'removeConstraint', 'removeConstraints',
+    'NSLocalizedString', 'Bundle',
+    'reloadData', 'reloadSections', 'reloadRows', 'performBatchUpdates',
+    'register', 'dequeueReusableCell', 'dequeueReusableSupplementaryView',
+    'beginUpdates', 'endUpdates', 'insertRows', 'deleteRows', 'insertSections', 'deleteSections',
+    'present', 'dismiss', 'pushViewController', 'popViewController', 'popToRootViewController',
+    'performSegue', 'prepare',
+    'DispatchQueue', 'async', 'sync', 'asyncAfter',
+    'Task', 'withCheckedContinuation', 'withCheckedThrowingContinuation',
+    'sink', 'store', 'assign', 'receive', 'subscribe',
+    'addObserver', 'removeObserver', 'post', 'NotificationCenter',
+]);
+export const swiftProvider = defineLanguage({
+    id: SupportedLanguages.Swift,
+    extensions: ['.swift'],
+    treeSitterQueries: SWIFT_QUERIES,
+    typeConfig: swiftConfig,
+    exportChecker: swiftExportChecker,
+    importResolver: resolveSwiftImport,
+    importSemantics: 'wildcard',
+    heritageDefaultEdge: 'IMPLEMENTS',
+    fieldExtractor: createFieldExtractor(swiftFieldConfig),
+    implicitImportWirer: wireSwiftImplicitImports,
+    builtInNames: BUILT_INS,
+});

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

@@ -0,0 +1,10 @@
+/**
+ * TypeScript and JavaScript language providers.
+ *
+ * Both languages share the same type extraction config (typescriptConfig),
+ * export checker (tsExportChecker), and named binding extractor
+ * (extractTsNamedBindings). They differ in file extensions, tree-sitter
+ * queries (TypeScript grammar has interface/type nodes), and language ID.
+ */
+export declare const typescriptProvider: import("../language-provider.js").LanguageProvider;
+export declare const javascriptProvider: import("../language-provider.js").LanguageProvider;