gitnexus 1.5.3 → 1.6.1

package/dist/core/ingestion/resolution-context.d.ts

@@ -1,58 +0,0 @@
-/**
- * Resolution Context
- *
- * Single implementation of tiered name resolution. Replaces the duplicated
- * tier-selection logic previously split between symbol-resolver.ts and
- * call-processor.ts.
- *
- * Resolution tiers (highest confidence first):
- * 1. Same file (lookupExactFull — authoritative)
- * 2a-named. Named binding chain (walkBindingChain via NamedImportMap)
- * 2a. Import-scoped (lookupFuzzy filtered by ImportMap)
- * 2b. Package-scoped (lookupFuzzy filtered by PackageMap)
- * 3. Global (all candidates — consumers must check candidate count)
- */
-import type { SymbolTable, SymbolDefinition } from './symbol-table.js';
-import type { NamedImportBinding } from './import-processor.js';
-/** Resolution tier for tracking, logging, and test assertions. */
-export type ResolutionTier = 'same-file' | 'import-scoped' | 'global';
-/** Tier-selected candidates with metadata. */
-export interface TieredCandidates {
-    readonly candidates: readonly SymbolDefinition[];
-    readonly tier: ResolutionTier;
-}
-/** Confidence scores per resolution tier. */
-export declare const TIER_CONFIDENCE: Record<ResolutionTier, number>;
-export type ImportMap = Map<string, Set<string>>;
-export type PackageMap = Map<string, Set<string>>;
-export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>;
-/** Maps callerFile → (moduleAlias → sourceFilePath) for Python namespace imports.
- *  e.g. `import models` in app.py → moduleAliasMap.get('app.py')?.get('models') === 'models.py' */
-export type ModuleAliasMap = Map<string, Map<string, string>>;
-export interface ResolutionContext {
-    /**
-     * The only resolution API. Returns all candidates at the winning tier.
-     *
-     * Tier 3 ('global') returns ALL candidates regardless of count —
-     * consumers must check candidates.length and refuse ambiguous matches.
-     */
-    resolve(name: string, fromFile: string): TieredCandidates | null;
-    /** Symbol table — used by parsing-processor to populate symbols. */
-    readonly symbols: SymbolTable;
-    /** Raw maps — used by import-processor to populate import data. */
-    readonly importMap: ImportMap;
-    readonly packageMap: PackageMap;
-    readonly namedImportMap: NamedImportMap;
-    /** Module-alias map for Python namespace imports: callerFile → (alias → sourceFile). */
-    readonly moduleAliasMap: ModuleAliasMap;
-    enableCache(filePath: string): void;
-    clearCache(): void;
-    getStats(): {
-        fileCount: number;
-        globalSymbolCount: number;
-        cacheHits: number;
-        cacheMisses: number;
-    };
-    clear(): void;
-}
-export declare const createResolutionContext: () => ResolutionContext;

package/dist/core/ingestion/resolution-context.js

@@ -1,135 +0,0 @@
-/**
- * Resolution Context
- *
- * Single implementation of tiered name resolution. Replaces the duplicated
- * tier-selection logic previously split between symbol-resolver.ts and
- * call-processor.ts.
- *
- * Resolution tiers (highest confidence first):
- * 1. Same file (lookupExactFull — authoritative)
- * 2a-named. Named binding chain (walkBindingChain via NamedImportMap)
- * 2a. Import-scoped (lookupFuzzy filtered by ImportMap)
- * 2b. Package-scoped (lookupFuzzy filtered by PackageMap)
- * 3. Global (all candidates — consumers must check candidate count)
- */
-import { createSymbolTable } from './symbol-table.js';
-import { isFileInPackageDir } from './import-processor.js';
-import { walkBindingChain } from './named-binding-processor.js';
-/** Confidence scores per resolution tier. */
-export const TIER_CONFIDENCE = {
-    'same-file': 0.95,
-    'import-scoped': 0.9,
-    global: 0.5,
-};
-export const createResolutionContext = () => {
-    const symbols = createSymbolTable();
-    const importMap = new Map();
-    const packageMap = new Map();
-    const namedImportMap = new Map();
-    const moduleAliasMap = new Map();
-    // Per-file cache state
-    let cacheFile = null;
-    let cache = null;
-    let cacheHits = 0;
-    let cacheMisses = 0;
-    // --- Core resolution (single implementation of tier logic) ---
-    const resolveUncached = (name, fromFile) => {
-        // Tier 1: Same file — authoritative match (returns all overloads)
-        const localDefs = symbols.lookupExactAll(fromFile, name);
-        if (localDefs.length > 0) {
-            return { candidates: localDefs, tier: 'same-file' };
-        }
-        // Get all global definitions for subsequent tiers
-        const allDefs = symbols.lookupFuzzy(name);
-        // Tier 2a-named: Check named bindings BEFORE empty-allDefs early return
-        // because aliased imports mean lookupFuzzy('U') returns empty but we
-        // can resolve via the exported name.
-        const chainResult = walkBindingChain(name, fromFile, symbols, namedImportMap, allDefs);
-        if (chainResult && chainResult.length > 0) {
-            return { candidates: chainResult, tier: 'import-scoped' };
-        }
-        if (allDefs.length === 0)
-            return null;
-        // Tier 2a: Import-scoped — definition in a file imported by fromFile
-        const importedFiles = importMap.get(fromFile);
-        if (importedFiles) {
-            const importedDefs = allDefs.filter((def) => importedFiles.has(def.filePath));
-            if (importedDefs.length > 0) {
-                return { candidates: importedDefs, tier: 'import-scoped' };
-            }
-        }
-        // Tier 2b: Package-scoped — definition in a package dir imported by fromFile
-        const importedPackages = packageMap.get(fromFile);
-        if (importedPackages) {
-            const packageDefs = allDefs.filter((def) => {
-                for (const dirSuffix of importedPackages) {
-                    if (isFileInPackageDir(def.filePath, dirSuffix))
-                        return true;
-                }
-                return false;
-            });
-            if (packageDefs.length > 0) {
-                return { candidates: packageDefs, tier: 'import-scoped' };
-            }
-        }
-        // Tier 3: Global — pass all candidates through.
-        // Consumers must check candidate count and refuse ambiguous matches.
-        return { candidates: allDefs, tier: 'global' };
-    };
-    const resolve = (name, fromFile) => {
-        // Check cache (only when enabled AND fromFile matches cached file)
-        if (cache && cacheFile === fromFile) {
-            if (cache.has(name)) {
-                cacheHits++;
-                return cache.get(name);
-            }
-            cacheMisses++;
-        }
-        const result = resolveUncached(name, fromFile);
-        // Store in cache if active and file matches
-        if (cache && cacheFile === fromFile) {
-            cache.set(name, result);
-        }
-        return result;
-    };
-    // --- Cache lifecycle ---
-    const enableCache = (filePath) => {
-        cacheFile = filePath;
-        if (!cache)
-            cache = new Map();
-        else
-            cache.clear();
-    };
-    const clearCache = () => {
-        cacheFile = null;
-        // Reuse the Map instance — just clear entries to reduce GC pressure at scale.
-        cache?.clear();
-    };
-    const getStats = () => ({
-        ...symbols.getStats(),
-        cacheHits,
-        cacheMisses,
-    });
-    const clear = () => {
-        symbols.clear();
-        importMap.clear();
-        packageMap.clear();
-        namedImportMap.clear();
-        moduleAliasMap.clear();
-        clearCache();
-        cacheHits = 0;
-        cacheMisses = 0;
-    };
-    return {
-        resolve,
-        symbols,
-        importMap,
-        packageMap,
-        namedImportMap,
-        moduleAliasMap,
-        enableCache,
-        clearCache,
-        getStats,
-        clear,
-    };
-};

package/dist/core/ingestion/symbol-table.d.ts

@@ -1,79 +0,0 @@
-import type { NodeLabel } from '../../_shared/index.js';
-export interface SymbolDefinition {
-    nodeId: string;
-    filePath: string;
-    type: NodeLabel;
-    parameterCount?: number;
-    /** Number of required (non-optional, non-default) parameters.
-     *  Enables range-based arity filtering: argCount >= requiredParameterCount && argCount <= parameterCount. */
-    requiredParameterCount?: number;
-    /** Per-parameter type names for overload disambiguation (e.g. ['int', 'String']).
-     *  Populated when parameter types are resolvable from AST (any typed language).
-     *  Used for disambiguation in overloading languages (Java, Kotlin, C#, C++). */
-    parameterTypes?: string[];
-    /** Raw return type text extracted from AST (e.g. 'User', 'Promise<User>') */
-    returnType?: string;
-    /** Declared type for non-callable symbols — fields/properties (e.g. 'Address', 'List<User>') */
-    declaredType?: string;
-    /** Links Method/Constructor/Property to owning Class/Struct/Trait nodeId */
-    ownerId?: string;
-}
-export interface SymbolTable {
-    /**
-     * Register a new symbol definition
-     */
-    add: (filePath: string, name: string, nodeId: string, type: NodeLabel, metadata?: {
-        parameterCount?: number;
-        requiredParameterCount?: number;
-        parameterTypes?: string[];
-        returnType?: string;
-        declaredType?: string;
-        ownerId?: string;
-    }) => void;
-    /**
-     * High Confidence: Look for a symbol specifically inside a file
-     * Returns the Node ID if found
-     */
-    lookupExact: (filePath: string, name: string) => string | undefined;
-    /**
-     * High Confidence: Look for a symbol in a specific file, returning full definition.
-     * Includes type information needed for heritage resolution (Class vs Interface).
-     * Returns first matching definition — use lookupExactAll for overloaded methods.
-     */
-    lookupExactFull: (filePath: string, name: string) => SymbolDefinition | undefined;
-    /**
-     * High Confidence: Look for ALL symbols with this name in a specific file.
-     * Returns all definitions, including overloaded methods with the same name.
-     * Used by resolution-context to pass all same-file overloads to candidate filtering.
-     */
-    lookupExactAll: (filePath: string, name: string) => SymbolDefinition[];
-    /**
-     * Low Confidence: Look for a symbol anywhere in the project
-     * Used when imports are missing or for framework magic
-     */
-    lookupFuzzy: (name: string) => SymbolDefinition[];
-    /**
-     * Low Confidence: Look for callable symbols (Function/Method/Constructor) by name.
-     * Faster than `lookupFuzzy` + filter — backed by a lazy callable-only index.
-     * Used by ReturnTypeLookup to resolve callee → return type.
-     */
-    lookupFuzzyCallable: (name: string) => SymbolDefinition[];
-    /**
-     * Look up a field/property by its owning class nodeId and field name.
-     * O(1) via dedicated eagerly-populated index keyed by `ownerNodeId\0fieldName`.
-     * Returns undefined when no matching property exists or the owner is ambiguous.
-     */
-    lookupFieldByOwner: (ownerNodeId: string, fieldName: string) => SymbolDefinition | undefined;
-    /**
-     * Debugging: See how many symbols are tracked
-     */
-    getStats: () => {
-        fileCount: number;
-        globalSymbolCount: number;
-    };
-    /**
-     * Cleanup memory
-     */
-    clear: () => void;
-}
-export declare const createSymbolTable: () => SymbolTable;

package/dist/core/ingestion/symbol-table.js

@@ -1,115 +0,0 @@
-export const createSymbolTable = () => {
-    // 1. File-Specific Index — stores full SymbolDefinition(s) for O(1) lookup.
-    // Structure: FilePath -> (SymbolName -> SymbolDefinition[])
-    // Array allows overloaded methods (same name, different signatures) to coexist.
-    const fileIndex = new Map();
-    // 2. Global Reverse Index (The "Backup")
-    // Structure: SymbolName -> [List of Definitions]
-    const globalIndex = new Map();
-    // 3. Lazy Callable Index — populated on first lookupFuzzyCallable call.
-    // Structure: SymbolName -> [Callable Definitions]
-    // Only Function, Method, Constructor symbols are indexed.
-    let callableIndex = null;
-    // 4. Eagerly-populated Field/Property Index — keyed by "ownerNodeId\0fieldName".
-    // Only Property symbols with ownerId and declaredType are indexed.
-    const fieldByOwner = new Map();
-    const CALLABLE_TYPES = new Set(['Function', 'Method', 'Constructor']);
-    const add = (filePath, name, nodeId, type, metadata) => {
-        const def = {
-            nodeId,
-            filePath,
-            type,
-            ...(metadata?.parameterCount !== undefined
-                ? { parameterCount: metadata.parameterCount }
-                : {}),
-            ...(metadata?.requiredParameterCount !== undefined
-                ? { requiredParameterCount: metadata.requiredParameterCount }
-                : {}),
-            ...(metadata?.parameterTypes !== undefined
-                ? { parameterTypes: metadata.parameterTypes }
-                : {}),
-            ...(metadata?.returnType !== undefined ? { returnType: metadata.returnType } : {}),
-            ...(metadata?.declaredType !== undefined ? { declaredType: metadata.declaredType } : {}),
-            ...(metadata?.ownerId !== undefined ? { ownerId: metadata.ownerId } : {}),
-        };
-        // A. Add to File Index (shared reference — zero additional memory)
-        if (!fileIndex.has(filePath)) {
-            fileIndex.set(filePath, new Map());
-        }
-        const fileMap = fileIndex.get(filePath);
-        if (!fileMap.has(name)) {
-            fileMap.set(name, [def]);
-        }
-        else {
-            fileMap.get(name).push(def);
-        }
-        // B. Properties go to fieldByOwner index only — skip globalIndex to prevent
-        // namespace pollution for common names like 'id', 'name', 'type'.
-        // Index ALL properties (even without declaredType) so write-access tracking
-        // can resolve field ownership for dynamically-typed languages (Ruby, JS).
-        if (type === 'Property' && metadata?.ownerId) {
-            fieldByOwner.set(`${metadata.ownerId}\0${name}`, def);
-            // Still add to fileIndex above (for lookupExact), but skip globalIndex
-            return;
-        }
-        // C. Add to Global Index (same object reference)
-        if (!globalIndex.has(name)) {
-            globalIndex.set(name, []);
-        }
-        globalIndex.get(name).push(def);
-        // D. Invalidate the lazy callable index only when adding callable types
-        if (CALLABLE_TYPES.has(type)) {
-            callableIndex = null;
-        }
-    };
-    const lookupExact = (filePath, name) => {
-        const defs = fileIndex.get(filePath)?.get(name);
-        return defs?.[0]?.nodeId;
-    };
-    const lookupExactFull = (filePath, name) => {
-        const defs = fileIndex.get(filePath)?.get(name);
-        return defs?.[0];
-    };
-    const lookupExactAll = (filePath, name) => {
-        return fileIndex.get(filePath)?.get(name) ?? [];
-    };
-    const lookupFuzzy = (name) => {
-        return globalIndex.get(name) || [];
-    };
-    const lookupFuzzyCallable = (name) => {
-        if (!callableIndex) {
-            // Build the callable index lazily on first use
-            callableIndex = new Map();
-            for (const [symName, defs] of globalIndex) {
-                const callables = defs.filter((d) => CALLABLE_TYPES.has(d.type));
-                if (callables.length > 0)
-                    callableIndex.set(symName, callables);
-            }
-        }
-        return callableIndex.get(name) ?? [];
-    };
-    const lookupFieldByOwner = (ownerNodeId, fieldName) => {
-        return fieldByOwner.get(`${ownerNodeId}\0${fieldName}`);
-    };
-    const getStats = () => ({
-        fileCount: fileIndex.size,
-        globalSymbolCount: globalIndex.size,
-    });
-    const clear = () => {
-        fileIndex.clear();
-        globalIndex.clear();
-        callableIndex = null;
-        fieldByOwner.clear();
-    };
-    return {
-        add,
-        lookupExact,
-        lookupExactFull,
-        lookupExactAll,
-        lookupFuzzy,
-        lookupFuzzyCallable,
-        lookupFieldByOwner,
-        getStats,
-        clear,
-    };
-};