gitnexus 1.4.8 → 1.4.9

package/dist/core/ingestion/named-binding-extraction.js

@@ -1,373 +0,0 @@
-import { findChild } from './resolvers/utils.js';
-/**
- * Walk a named-binding re-export chain through NamedImportMap.
- *
- * When file A imports { User } from B, and B re-exports { User } from C,
- * the NamedImportMap for A points to B, but B has no User definition.
- * This function follows the chain: A→B→C until a definition is found.
- *
- * Returns the definitions found at the end of the chain, or null if the
- * chain breaks (missing binding, circular reference, or depth exceeded).
- * Max depth 5 to prevent infinite loops.
- *
- * @param allDefs Pre-computed `symbolTable.lookupFuzzy(name)` result — must be the
- *               complete unfiltered result. Passing a file-filtered subset will cause
- *               silent misses at depth=0 for non-aliased bindings.
- */
-export function walkBindingChain(name, currentFilePath, symbolTable, namedImportMap, allDefs) {
-    let lookupFile = currentFilePath;
-    let lookupName = name;
-    const visited = new Set();
-    for (let depth = 0; depth < 5; depth++) {
-        const bindings = namedImportMap.get(lookupFile);
-        if (!bindings)
-            return null;
-        const binding = bindings.get(lookupName);
-        if (!binding)
-            return null;
-        const key = `${binding.sourcePath}:${binding.exportedName}`;
-        if (visited.has(key))
-            return null; // circular
-        visited.add(key);
-        const targetName = binding.exportedName;
-        const resolvedDefs = targetName !== lookupName || depth > 0
-            ? symbolTable.lookupFuzzy(targetName).filter(def => def.filePath === binding.sourcePath)
-            : allDefs.filter(def => def.filePath === binding.sourcePath);
-        if (resolvedDefs.length > 0)
-            return resolvedDefs;
-        // No definition in source file → follow re-export chain
-        lookupFile = binding.sourcePath;
-        lookupName = targetName;
-    }
-    return null;
-}
-export function extractTsNamedBindings(importNode) {
-    // import_statement > import_clause > named_imports > import_specifier*
-    const importClause = findChild(importNode, 'import_clause');
-    if (importClause) {
-        const namedImports = findChild(importClause, 'named_imports');
-        if (!namedImports)
-            return undefined; // default import, namespace import, or side-effect
-        const bindings = [];
-        for (let i = 0; i < namedImports.namedChildCount; i++) {
-            const specifier = namedImports.namedChild(i);
-            if (specifier?.type !== 'import_specifier')
-                continue;
-            const identifiers = [];
-            for (let j = 0; j < specifier.namedChildCount; j++) {
-                const child = specifier.namedChild(j);
-                if (child?.type === 'identifier')
-                    identifiers.push(child.text);
-            }
-            if (identifiers.length === 1) {
-                bindings.push({ local: identifiers[0], exported: identifiers[0] });
-            }
-            else if (identifiers.length === 2) {
-                // import { Foo as Bar } → exported='Foo', local='Bar'
-                bindings.push({ local: identifiers[1], exported: identifiers[0] });
-            }
-        }
-        return bindings.length > 0 ? bindings : undefined;
-    }
-    // Re-export: export { X } from './y' → export_statement > export_clause > export_specifier
-    const exportClause = findChild(importNode, 'export_clause');
-    if (exportClause) {
-        const bindings = [];
-        for (let i = 0; i < exportClause.namedChildCount; i++) {
-            const specifier = exportClause.namedChild(i);
-            if (specifier?.type !== 'export_specifier')
-                continue;
-            const identifiers = [];
-            for (let j = 0; j < specifier.namedChildCount; j++) {
-                const child = specifier.namedChild(j);
-                if (child?.type === 'identifier')
-                    identifiers.push(child.text);
-            }
-            if (identifiers.length === 1) {
-                // export { User } from './base' → re-exports User as User
-                bindings.push({ local: identifiers[0], exported: identifiers[0] });
-            }
-            else if (identifiers.length === 2) {
-                // export { Repo as Repository } from './models' → name=Repo, alias=Repository
-                // For re-exports, the first id is the source name, second is what's exported
-                // When another file imports { Repository }, they get Repo from the source
-                bindings.push({ local: identifiers[1], exported: identifiers[0] });
-            }
-        }
-        return bindings.length > 0 ? bindings : undefined;
-    }
-    return undefined;
-}
-export function extractPythonNamedBindings(importNode) {
-    // Handle: from x import User, Repo as R
-    if (importNode.type === 'import_from_statement') {
-        const bindings = [];
-        for (let i = 0; i < importNode.namedChildCount; i++) {
-            const child = importNode.namedChild(i);
-            if (!child)
-                continue;
-            if (child.type === 'dotted_name') {
-                // Skip the module_name (first dotted_name is the source module)
-                const fieldName = importNode.childForFieldName?.('module_name');
-                if (fieldName && child.startIndex === fieldName.startIndex)
-                    continue;
-                // This is an imported name: from x import User
-                const name = child.text;
-                if (name)
-                    bindings.push({ local: name, exported: name });
-            }
-            if (child.type === 'aliased_import') {
-                // from x import Repo as R
-                const dottedName = findChild(child, 'dotted_name');
-                const aliasIdent = findChild(child, 'identifier');
-                if (dottedName && aliasIdent) {
-                    bindings.push({ local: aliasIdent.text, exported: dottedName.text });
-                }
-            }
-        }
-        return bindings.length > 0 ? bindings : undefined;
-    }
-    // Handle: import numpy as np  (import_statement with aliased_import child)
-    // Tagged with isModuleAlias so applyImportResult routes these directly to
-    // moduleAliasMap (e.g. "np" → "numpy.py") instead of namedImportMap.
-    if (importNode.type === 'import_statement') {
-        const bindings = [];
-        for (let i = 0; i < importNode.namedChildCount; i++) {
-            const child = importNode.namedChild(i);
-            if (!child || child.type !== 'aliased_import')
-                continue;
-            const dottedName = findChild(child, 'dotted_name');
-            const aliasIdent = findChild(child, 'identifier');
-            if (dottedName && aliasIdent) {
-                bindings.push({ local: aliasIdent.text, exported: dottedName.text, isModuleAlias: true });
-            }
-        }
-        return bindings.length > 0 ? bindings : undefined;
-    }
-    return undefined;
-}
-export function extractKotlinNamedBindings(importNode) {
-    // import_header > identifier + import_alias > simple_identifier
-    if (importNode.type !== 'import_header')
-        return undefined;
-    const fullIdent = findChild(importNode, 'identifier');
-    if (!fullIdent)
-        return undefined;
-    const fullText = fullIdent.text;
-    const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
-    const importAlias = findChild(importNode, 'import_alias');
-    if (importAlias) {
-        // Aliased: import com.example.User as U
-        const aliasIdent = findChild(importAlias, 'simple_identifier');
-        if (!aliasIdent)
-            return undefined;
-        return [{ local: aliasIdent.text, exported: exportedName }];
-    }
-    // Non-aliased: import com.example.User → local="User", exported="User"
-    // Also handles top-level function imports: import models.getUser → local="getUser"
-    // Skip wildcard imports (ending in *)
-    if (fullText.endsWith('.*') || fullText.endsWith('*'))
-        return undefined;
-    // Skip class-member imports (e.g., import util.OneArg.writeAudit) where the
-    // second-to-last segment is PascalCase (a class name). Multiple member imports
-    // with the same function name would collide in NamedImportMap, breaking
-    // arity-based disambiguation. Top-level function imports (import models.getUser)
-    // and class imports (import models.User) have package-only prefixes.
-    const segments = fullText.split('.');
-    if (segments.length >= 3) {
-        const parentSegment = segments[segments.length - 2];
-        if (parentSegment[0] && parentSegment[0] === parentSegment[0].toUpperCase())
-            return undefined;
-    }
-    return [{ local: exportedName, exported: exportedName }];
-}
-export function extractRustNamedBindings(importNode) {
-    // use_declaration may contain use_as_clause at any depth
-    if (importNode.type !== 'use_declaration')
-        return undefined;
-    const bindings = [];
-    collectRustBindings(importNode, bindings);
-    return bindings.length > 0 ? bindings : undefined;
-}
-function collectRustBindings(node, bindings) {
-    if (node.type === 'use_as_clause') {
-        // First identifier = exported name, second identifier = local alias
-        const idents = [];
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'identifier')
-                idents.push(child.text);
-            // For scoped_identifier, extract the last segment
-            if (child?.type === 'scoped_identifier') {
-                const nameNode = child.childForFieldName?.('name');
-                if (nameNode)
-                    idents.push(nameNode.text);
-            }
-        }
-        if (idents.length === 2) {
-            bindings.push({ local: idents[1], exported: idents[0] });
-        }
-        return;
-    }
-    // Terminal identifier in a use_list: use crate::models::{User, Repo}
-    if (node.type === 'identifier' && node.parent?.type === 'use_list') {
-        bindings.push({ local: node.text, exported: node.text });
-        return;
-    }
-    // Skip scoped_identifier that serves as path prefix in scoped_use_list
-    // e.g. use crate::models::{User, Repo} — the path node "crate::models" is not an importable symbol
-    if (node.type === 'scoped_identifier' && node.parent?.type === 'scoped_use_list') {
-        return; // path prefix — the use_list sibling handles the actual symbols
-    }
-    // Terminal scoped_identifier: use crate::models::User;
-    // Only extract if this is a leaf (no deeper use_list/use_as_clause/scoped_use_list)
-    if (node.type === 'scoped_identifier') {
-        let hasDeeper = false;
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'use_list' || child?.type === 'use_as_clause' || child?.type === 'scoped_use_list') {
-                hasDeeper = true;
-                break;
-            }
-        }
-        if (!hasDeeper) {
-            const nameNode = node.childForFieldName?.('name');
-            if (nameNode) {
-                bindings.push({ local: nameNode.text, exported: nameNode.text });
-            }
-            return;
-        }
-    }
-    // Recurse into children
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child)
-            collectRustBindings(child, bindings);
-    }
-}
-export function extractPhpNamedBindings(importNode) {
-    // namespace_use_declaration > namespace_use_clause* (flat)
-    // namespace_use_declaration > namespace_use_group > namespace_use_clause* (grouped)
-    if (importNode.type !== 'namespace_use_declaration')
-        return undefined;
-    // Skip 'use function' and 'use const' declarations — these import callables/constants,
-    // not class types, and should not be added to namedImportMap as type bindings.
-    const useTypeNode = importNode.childForFieldName?.('type');
-    if (useTypeNode && (useTypeNode.text === 'function' || useTypeNode.text === 'const')) {
-        return undefined;
-    }
-    const bindings = [];
-    // Collect all clauses — from direct children AND from namespace_use_group
-    const clauses = [];
-    for (let i = 0; i < importNode.namedChildCount; i++) {
-        const child = importNode.namedChild(i);
-        if (child?.type === 'namespace_use_clause') {
-            clauses.push(child);
-        }
-        else if (child?.type === 'namespace_use_group') {
-            for (let j = 0; j < child.namedChildCount; j++) {
-                const groupChild = child.namedChild(j);
-                if (groupChild?.type === 'namespace_use_clause')
-                    clauses.push(groupChild);
-            }
-        }
-    }
-    for (const clause of clauses) {
-        // Flat imports: qualified_name + name (alias)
-        let qualifiedName = null;
-        const names = [];
-        for (let j = 0; j < clause.namedChildCount; j++) {
-            const child = clause.namedChild(j);
-            if (child?.type === 'qualified_name')
-                qualifiedName = child;
-            else if (child?.type === 'name')
-                names.push(child);
-        }
-        if (qualifiedName && names.length > 0) {
-            // Flat aliased import: use App\Models\Repo as R;
-            const fullText = qualifiedName.text;
-            const exportedName = fullText.includes('\\') ? fullText.split('\\').pop() : fullText;
-            bindings.push({ local: names[0].text, exported: exportedName });
-        }
-        else if (qualifiedName && names.length === 0) {
-            // Flat non-aliased import: use App\Models\User;
-            const fullText = qualifiedName.text;
-            const lastSegment = fullText.includes('\\') ? fullText.split('\\').pop() : fullText;
-            bindings.push({ local: lastSegment, exported: lastSegment });
-        }
-        else if (!qualifiedName && names.length >= 2) {
-            // Grouped aliased import: {Repo as R} — first name = exported, second = alias
-            bindings.push({ local: names[1].text, exported: names[0].text });
-        }
-        else if (!qualifiedName && names.length === 1) {
-            // Grouped non-aliased import: {User} in use App\Models\{User, Repo as R}
-            bindings.push({ local: names[0].text, exported: names[0].text });
-        }
-    }
-    return bindings.length > 0 ? bindings : undefined;
-}
-export function extractCsharpNamedBindings(importNode) {
-    // using_directive — three forms:
-    //   using Alias = NS.Type;          → aliasIdent + qualifiedName
-    //   using static NS.Type;           → static + qualifiedName (no alias)
-    //   using NS;                       → qualifiedName only (namespace, not capturable)
-    if (importNode.type !== 'using_directive')
-        return undefined;
-    let aliasIdent = null;
-    let qualifiedName = null;
-    let isStatic = false;
-    for (let i = 0; i < importNode.childCount; i++) {
-        const child = importNode.child(i);
-        if (child?.text === 'static')
-            isStatic = true;
-    }
-    for (let i = 0; i < importNode.namedChildCount; i++) {
-        const child = importNode.namedChild(i);
-        if (child?.type === 'identifier' && !aliasIdent)
-            aliasIdent = child;
-        else if (child?.type === 'qualified_name')
-            qualifiedName = child;
-    }
-    // Form 1: using Alias = NS.Type;
-    if (aliasIdent && qualifiedName) {
-        const fullText = qualifiedName.text;
-        const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
-        return [{ local: aliasIdent.text, exported: exportedName }];
-    }
-    // Form 2: using static NS.Type; — last segment is the class name
-    if (isStatic && qualifiedName) {
-        const fullText = qualifiedName.text;
-        const lastSegment = fullText.includes('.') ? fullText.split('.').pop() : fullText;
-        return [{ local: lastSegment, exported: lastSegment }];
-    }
-    // Form 3: using NS; — namespace import, can't resolve to per-symbol bindings
-    return undefined;
-}
-export function extractJavaNamedBindings(importNode) {
-    // import_declaration > scoped_identifier "com.example.models.User"
-    // Wildcard imports (.*) don't produce named bindings
-    if (importNode.type !== 'import_declaration')
-        return undefined;
-    // Check for asterisk (wildcard import) and static modifier
-    let isStatic = false;
-    for (let i = 0; i < importNode.childCount; i++) {
-        const child = importNode.child(i);
-        if (child?.type === 'asterisk')
-            return undefined;
-        if (child?.text === 'static')
-            isStatic = true;
-    }
-    const scopedId = findChild(importNode, 'scoped_identifier');
-    if (!scopedId)
-        return undefined;
-    const fullText = scopedId.text;
-    const lastDot = fullText.lastIndexOf('.');
-    if (lastDot === -1)
-        return undefined;
-    const name = fullText.slice(lastDot + 1);
-    // Non-static: skip lowercase names — those are package imports, not class imports.
-    // Static: allow lowercase — `import static models.UserFactory.getUser` imports a method.
-    if (!isStatic && name[0] && name[0] === name[0].toLowerCase())
-        return undefined;
-    return [{ local: name, exported: name }];
-}

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

@@ -1,18 +0,0 @@
-/**
- * Language-specific import resolvers.
- * Extracted from import-processor.ts for maintainability.
- */
-export { EXTENSIONS, tryResolveWithExtensions, buildSuffixIndex, suffixResolve, EMPTY_INDEX } from './utils.js';
-export type { SuffixIndex } from './utils.js';
-export { KOTLIN_EXTENSIONS, appendKotlinWildcard, resolveJvmWildcard, resolveJvmMemberImport } from './jvm.js';
-export { resolveGoPackageDir, resolveGoPackage } from './go.js';
-export type { GoModuleConfig } from './go.js';
-export { resolveCSharpImport, resolveCSharpNamespaceDir } from './csharp.js';
-export type { CSharpProjectConfig } from './csharp.js';
-export { resolvePhpImport } from './php.js';
-export type { ComposerConfig } from './php.js';
-export { resolveRustImport, tryRustModulePath } from './rust.js';
-export { resolveRubyImport } from './ruby.js';
-export { resolvePythonImport } from './python.js';
-export { resolveImportPath, RESOLVE_CACHE_CAP } from './standard.js';
-export type { TsconfigPaths } from './standard.js';

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

@@ -1,13 +0,0 @@
-/**
- * Language-specific import resolvers.
- * Extracted from import-processor.ts for maintainability.
- */
-export { EXTENSIONS, tryResolveWithExtensions, buildSuffixIndex, suffixResolve, EMPTY_INDEX } from './utils.js';
-export { KOTLIN_EXTENSIONS, appendKotlinWildcard, resolveJvmWildcard, resolveJvmMemberImport } from './jvm.js';
-export { resolveGoPackageDir, resolveGoPackage } from './go.js';
-export { resolveCSharpImport, resolveCSharpNamespaceDir } from './csharp.js';
-export { resolvePhpImport } from './php.js';
-export { resolveRustImport, tryRustModulePath } from './rust.js';
-export { resolveRubyImport } from './ruby.js';
-export { resolvePythonImport } from './python.js';
-export { resolveImportPath, RESOLVE_CACHE_CAP } from './standard.js';

package/dist/core/ingestion/type-extractors/index.d.ts

@@ -1,22 +0,0 @@
-/**
- * Per-language type extraction configurations.
- * Assembled here into a dispatch map keyed by SupportedLanguages.
- */
-import type { LanguageTypeConfig } from './types.js';
-export declare const typeConfigs: {
-    javascript: LanguageTypeConfig;
-    typescript: LanguageTypeConfig;
-    java: LanguageTypeConfig;
-    kotlin: LanguageTypeConfig;
-    csharp: LanguageTypeConfig;
-    go: LanguageTypeConfig;
-    rust: LanguageTypeConfig;
-    python: LanguageTypeConfig;
-    swift: LanguageTypeConfig;
-    c: LanguageTypeConfig;
-    cpp: LanguageTypeConfig;
-    php: LanguageTypeConfig;
-    ruby: LanguageTypeConfig;
-};
-export type { LanguageTypeConfig, TypeBindingExtractor, ParameterExtractor, ConstructorBindingScanner, ForLoopExtractor, PendingAssignmentExtractor, PatternBindingExtractor, } from './types.js';
-export { TYPED_PARAMETER_TYPES, extractSimpleTypeName, extractGenericTypeArgs, extractVarName, extractRubyConstructorAssignment } from './shared.js';

package/dist/core/ingestion/type-extractors/index.js

@@ -1,31 +0,0 @@
-/**
- * Per-language type extraction configurations.
- * Assembled here into a dispatch map keyed by SupportedLanguages.
- */
-import { SupportedLanguages } from '../../../config/supported-languages.js';
-import { typeConfig as typescriptConfig } from './typescript.js';
-import { javaTypeConfig, kotlinTypeConfig } from './jvm.js';
-import { typeConfig as csharpConfig } from './csharp.js';
-import { typeConfig as goConfig } from './go.js';
-import { typeConfig as rustConfig } from './rust.js';
-import { typeConfig as pythonConfig } from './python.js';
-import { typeConfig as swiftConfig } from './swift.js';
-import { typeConfig as cCppConfig } from './c-cpp.js';
-import { typeConfig as phpConfig } from './php.js';
-import { typeConfig as rubyConfig } from './ruby.js';
-export const typeConfigs = {
-    [SupportedLanguages.JavaScript]: typescriptConfig,
-    [SupportedLanguages.TypeScript]: typescriptConfig,
-    [SupportedLanguages.Java]: javaTypeConfig,
-    [SupportedLanguages.Kotlin]: kotlinTypeConfig,
-    [SupportedLanguages.CSharp]: csharpConfig,
-    [SupportedLanguages.Go]: goConfig,
-    [SupportedLanguages.Rust]: rustConfig,
-    [SupportedLanguages.Python]: pythonConfig,
-    [SupportedLanguages.Swift]: swiftConfig,
-    [SupportedLanguages.C]: cCppConfig,
-    [SupportedLanguages.CPlusPlus]: cCppConfig,
-    [SupportedLanguages.PHP]: phpConfig,
-    [SupportedLanguages.Ruby]: rubyConfig,
-};
-export { TYPED_PARAMETER_TYPES, extractSimpleTypeName, extractGenericTypeArgs, extractVarName, extractRubyConstructorAssignment } from './shared.js';

package/dist/core/ingestion/utils.d.ts

@@ -1,20 +0,0 @@
-import { SupportedLanguages } from '../../config/supported-languages.js';
-/**
- * Built-in function/method names that should not be tracked as call targets.
- * Covers JS/TS, Python, Kotlin, C/C++, PHP, Swift standard library functions.
- */
-export declare const BUILT_IN_NAMES: Set<string>;
-/** Check if a name is a built-in function or common noise that should be filtered out */
-export declare const isBuiltInOrNoise: (name: string) => boolean;
-/**
- * Yield control to the event loop so spinners/progress can render.
- * Call periodically in hot loops to prevent UI freezes.
- */
-export declare const yieldToEventLoop: () => Promise<void>;
-/**
- * Map file extension to SupportedLanguage enum
- */
-export declare const getLanguageFromFilename: (filename: string) => SupportedLanguages | null;
-export declare const isVerboseIngestionEnabled: () => boolean;
-export * from './ast-helpers.js';
-export * from './call-analysis.js';