gitnexus 1.4.0 → 1.4.1

package/dist/core/ingestion/mro-processor.js

@@ -1,369 +0,0 @@
-/**
- * MRO (Method Resolution Order) Processor
- *
- * Walks the inheritance DAG (EXTENDS/IMPLEMENTS edges), collects methods from
- * each ancestor via HAS_METHOD edges, detects method-name collisions across
- * parents, and applies language-specific resolution rules to emit OVERRIDES edges.
- *
- * Language-specific rules:
- * - C++:       leftmost base class in declaration order wins
- * - C#/Java:   class method wins over interface default; multiple interface
- *              methods with same name are ambiguous (null resolution)
- * - Python:    C3 linearization determines MRO; first in linearized order wins
- * - Rust:      no auto-resolution — requires qualified syntax, resolvedTo = null
- * - Default:   single inheritance — first definition wins
- *
- * OVERRIDES edge direction: Class → Method (not Method → Method).
- * The source is the child class that inherits conflicting methods,
- * the target is the winning ancestor method node.
- * Cypher: MATCH (c:Class)-[r:CodeRelation {type: 'OVERRIDES'}]->(m:Method)
- */
-import { generateId } from '../../lib/utils.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-/** Collect EXTENDS, IMPLEMENTS, and HAS_METHOD adjacency from the graph. */
-function buildAdjacency(graph) {
-    // parentMap: childId → parentIds[] (in insertion / declaration order)
-    const parentMap = new Map();
-    // methodMap: classId → methodIds[]
-    const methodMap = new Map();
-    // Track which edge type each parent link came from
-    const parentEdgeType = new Map();
-    graph.forEachRelationship((rel) => {
-        if (rel.type === 'EXTENDS' || rel.type === 'IMPLEMENTS') {
-            let parents = parentMap.get(rel.sourceId);
-            if (!parents) {
-                parents = [];
-                parentMap.set(rel.sourceId, parents);
-            }
-            parents.push(rel.targetId);
-            let edgeTypes = parentEdgeType.get(rel.sourceId);
-            if (!edgeTypes) {
-                edgeTypes = new Map();
-                parentEdgeType.set(rel.sourceId, edgeTypes);
-            }
-            edgeTypes.set(rel.targetId, rel.type);
-        }
-        if (rel.type === 'HAS_METHOD') {
-            let methods = methodMap.get(rel.sourceId);
-            if (!methods) {
-                methods = [];
-                methodMap.set(rel.sourceId, methods);
-            }
-            methods.push(rel.targetId);
-        }
-    });
-    return { parentMap, methodMap, parentEdgeType };
-}
-/**
- * Gather all ancestor IDs in BFS / topological order.
- * Returns the linearized list of ancestor IDs (excluding the class itself).
- */
-function gatherAncestors(classId, parentMap) {
-    const visited = new Set();
-    const order = [];
-    const queue = [...(parentMap.get(classId) ?? [])];
-    while (queue.length > 0) {
-        const id = queue.shift();
-        if (visited.has(id))
-            continue;
-        visited.add(id);
-        order.push(id);
-        const grandparents = parentMap.get(id);
-        if (grandparents) {
-            for (const gp of grandparents) {
-                if (!visited.has(gp))
-                    queue.push(gp);
-            }
-        }
-    }
-    return order;
-}
-// ---------------------------------------------------------------------------
-// C3 linearization (Python MRO)
-// ---------------------------------------------------------------------------
-/**
- * Compute C3 linearization for a class given a parentMap.
- * Returns an array of ancestor IDs in C3 order (excluding the class itself),
- * or null if linearization fails (inconsistent or cyclic hierarchy).
- */
-function c3Linearize(classId, parentMap, cache, inProgress) {
-    if (cache.has(classId))
-        return cache.get(classId);
-    // Cycle detection: if we're already computing this class, the hierarchy is cyclic
-    const visiting = inProgress ?? new Set();
-    if (visiting.has(classId)) {
-        cache.set(classId, null);
-        return null;
-    }
-    visiting.add(classId);
-    const directParents = parentMap.get(classId);
-    if (!directParents || directParents.length === 0) {
-        visiting.delete(classId);
-        cache.set(classId, []);
-        return [];
-    }
-    // Compute linearization for each parent first
-    const parentLinearizations = [];
-    for (const pid of directParents) {
-        const pLin = c3Linearize(pid, parentMap, cache, visiting);
-        if (pLin === null) {
-            visiting.delete(classId);
-            cache.set(classId, null);
-            return null;
-        }
-        parentLinearizations.push([pid, ...pLin]);
-    }
-    // Add the direct parents list as the final sequence
-    const sequences = [...parentLinearizations, [...directParents]];
-    const result = [];
-    while (sequences.some(s => s.length > 0)) {
-        // Find a good head: one that doesn't appear in the tail of any other sequence
-        let head = null;
-        for (const seq of sequences) {
-            if (seq.length === 0)
-                continue;
-            const candidate = seq[0];
-            const inTail = sequences.some(other => other.length > 1 && other.indexOf(candidate, 1) !== -1);
-            if (!inTail) {
-                head = candidate;
-                break;
-            }
-        }
-        if (head === null) {
-            // Inconsistent hierarchy
-            visiting.delete(classId);
-            cache.set(classId, null);
-            return null;
-        }
-        result.push(head);
-        // Remove the chosen head from all sequences
-        for (const seq of sequences) {
-            if (seq.length > 0 && seq[0] === head) {
-                seq.shift();
-            }
-        }
-    }
-    visiting.delete(classId);
-    cache.set(classId, result);
-    return result;
-}
-/** Resolve by MRO order — first ancestor in linearized order wins. */
-function resolveByMroOrder(methodName, defs, mroOrder, reasonPrefix) {
-    for (const ancestorId of mroOrder) {
-        const match = defs.find(d => d.classId === ancestorId);
-        if (match) {
-            return {
-                resolvedTo: match.methodId,
-                reason: `${reasonPrefix}: ${match.className}::${methodName}`,
-            };
-        }
-    }
-    return { resolvedTo: defs[0].methodId, reason: `${reasonPrefix} fallback: first definition` };
-}
-function resolveCsharpJava(methodName, defs, parentEdgeTypes) {
-    const classDefs = [];
-    const interfaceDefs = [];
-    for (const def of defs) {
-        const edgeType = parentEdgeTypes?.get(def.classId);
-        if (edgeType === 'IMPLEMENTS') {
-            interfaceDefs.push(def);
-        }
-        else {
-            classDefs.push(def);
-        }
-    }
-    if (classDefs.length > 0) {
-        return {
-            resolvedTo: classDefs[0].methodId,
-            reason: `class method wins: ${classDefs[0].className}::${methodName}`,
-        };
-    }
-    if (interfaceDefs.length > 1) {
-        return {
-            resolvedTo: null,
-            reason: `ambiguous: ${methodName} defined in multiple interfaces: ${interfaceDefs.map(d => d.className).join(', ')}`,
-        };
-    }
-    if (interfaceDefs.length === 1) {
-        return {
-            resolvedTo: interfaceDefs[0].methodId,
-            reason: `single interface default: ${interfaceDefs[0].className}::${methodName}`,
-        };
-    }
-    return { resolvedTo: null, reason: 'no resolution found' };
-}
-// ---------------------------------------------------------------------------
-// Main entry point
-// ---------------------------------------------------------------------------
-export function computeMRO(graph) {
-    const { parentMap, methodMap, parentEdgeType } = buildAdjacency(graph);
-    const c3Cache = new Map();
-    const entries = [];
-    let overrideEdges = 0;
-    let ambiguityCount = 0;
-    // Process every class that has at least one parent
-    for (const [classId, directParents] of parentMap) {
-        if (directParents.length === 0)
-            continue;
-        const classNode = graph.getNode(classId);
-        if (!classNode)
-            continue;
-        const language = classNode.properties.language;
-        if (!language)
-            continue;
-        const className = classNode.properties.name;
-        // Compute linearized MRO depending on language
-        let mroOrder;
-        if (language === SupportedLanguages.Python) {
-            const c3Result = c3Linearize(classId, parentMap, c3Cache);
-            mroOrder = c3Result ?? gatherAncestors(classId, parentMap);
-        }
-        else {
-            mroOrder = gatherAncestors(classId, parentMap);
-        }
-        // Get the parent names for the MRO entry
-        const mroNames = mroOrder
-            .map(id => graph.getNode(id)?.properties.name)
-            .filter((n) => n !== undefined);
-        // Collect methods from all ancestors, grouped by method name
-        const methodsByName = new Map();
-        for (const ancestorId of mroOrder) {
-            const ancestorNode = graph.getNode(ancestorId);
-            if (!ancestorNode)
-                continue;
-            const methods = methodMap.get(ancestorId) ?? [];
-            for (const methodId of methods) {
-                const methodNode = graph.getNode(methodId);
-                if (!methodNode)
-                    continue;
-                // Properties don't participate in method resolution order
-                if (methodNode.label === 'Property')
-                    continue;
-                const methodName = methodNode.properties.name;
-                let defs = methodsByName.get(methodName);
-                if (!defs) {
-                    defs = [];
-                    methodsByName.set(methodName, defs);
-                }
-                // Avoid duplicates (same method seen via multiple paths)
-                if (!defs.some(d => d.methodId === methodId)) {
-                    defs.push({
-                        classId: ancestorId,
-                        className: ancestorNode.properties.name,
-                        methodId,
-                    });
-                }
-            }
-        }
-        // Detect collisions: methods defined in 2+ different ancestors
-        const ambiguities = [];
-        // Compute transitive edge types once per class (only needed for C#/Java)
-        const needsEdgeTypes = language === SupportedLanguages.CSharp || language === SupportedLanguages.Java || language === SupportedLanguages.Kotlin;
-        const classEdgeTypes = needsEdgeTypes
-            ? buildTransitiveEdgeTypes(classId, parentMap, parentEdgeType)
-            : undefined;
-        for (const [methodName, defs] of methodsByName) {
-            if (defs.length < 2)
-                continue;
-            // Own method shadows inherited — no ambiguity
-            const ownMethods = methodMap.get(classId) ?? [];
-            const ownDefinesIt = ownMethods.some(mid => {
-                const mn = graph.getNode(mid);
-                return mn?.properties.name === methodName;
-            });
-            if (ownDefinesIt)
-                continue;
-            let resolution;
-            switch (language) {
-                case SupportedLanguages.CPlusPlus:
-                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'C++ leftmost base');
-                    break;
-                case SupportedLanguages.CSharp:
-                case SupportedLanguages.Java:
-                case SupportedLanguages.Kotlin:
-                    resolution = resolveCsharpJava(methodName, defs, classEdgeTypes);
-                    break;
-                case SupportedLanguages.Python:
-                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'Python C3 MRO');
-                    break;
-                case SupportedLanguages.Rust:
-                    resolution = {
-                        resolvedTo: null,
-                        reason: `Rust requires qualified syntax: <Type as Trait>::${methodName}()`,
-                    };
-                    break;
-                default:
-                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'first definition');
-                    break;
-            }
-            const ambiguity = {
-                methodName,
-                definedIn: defs,
-                resolvedTo: resolution.resolvedTo,
-                reason: resolution.reason,
-            };
-            ambiguities.push(ambiguity);
-            if (resolution.resolvedTo === null) {
-                ambiguityCount++;
-            }
-            // Emit OVERRIDES edge if resolution found
-            if (resolution.resolvedTo !== null) {
-                graph.addRelationship({
-                    id: generateId('OVERRIDES', `${classId}->${resolution.resolvedTo}`),
-                    sourceId: classId,
-                    targetId: resolution.resolvedTo,
-                    type: 'OVERRIDES',
-                    confidence: 1.0,
-                    reason: resolution.reason,
-                });
-                overrideEdges++;
-            }
-        }
-        entries.push({
-            classId,
-            className,
-            language,
-            mro: mroNames,
-            ambiguities,
-        });
-    }
-    return { entries, overrideEdges, ambiguityCount };
-}
-/**
- * Build transitive edge types for a class using BFS from the class to all ancestors.
- *
- * Known limitation: BFS first-reach heuristic can misclassify an interface as
- * EXTENDS if it's reachable via a class chain before being seen via IMPLEMENTS.
- * E.g. if BaseClass also implements IFoo, IFoo may be classified as EXTENDS.
- * This affects C#/Java/Kotlin conflict resolution in rare diamond hierarchies.
- */
-function buildTransitiveEdgeTypes(classId, parentMap, parentEdgeType) {
-    const result = new Map();
-    const directEdges = parentEdgeType.get(classId);
-    if (!directEdges)
-        return result;
-    // BFS: propagate edge type from direct parents
-    const queue = [];
-    const directParents = parentMap.get(classId) ?? [];
-    for (const pid of directParents) {
-        const et = directEdges.get(pid) ?? 'EXTENDS';
-        if (!result.has(pid)) {
-            result.set(pid, et);
-            queue.push({ id: pid, edgeType: et });
-        }
-    }
-    while (queue.length > 0) {
-        const { id, edgeType } = queue.shift();
-        const grandparents = parentMap.get(id) ?? [];
-        for (const gp of grandparents) {
-            if (!result.has(gp)) {
-                result.set(gp, edgeType);
-                queue.push({ id: gp, edgeType });
-            }
-        }
-    }
-    return result;
-}

package/dist/core/ingestion/named-binding-extraction.d.ts

@@ -1,61 +0,0 @@
-import { SupportedLanguages } from '../../config/supported-languages.js';
-import type { SymbolTable, SymbolDefinition } from './symbol-table.js';
-import type { NamedImportMap } from './import-processor.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 declare function walkBindingChain(name: string, currentFilePath: string, symbolTable: SymbolTable, namedImportMap: NamedImportMap, allDefs: SymbolDefinition[]): SymbolDefinition[] | null;
-/**
- * Extract named bindings from an import AST node.
- * Returns undefined if the import is not a named import (e.g., import * or default).
- *
- * TS: import { User, Repo as R } from './models'
- *   → [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}]
- *
- * Python: from models import User, Repo as R
- *   → [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}]
- */
-export declare function extractNamedBindings(importNode: any, language: SupportedLanguages): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractTsNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractPythonNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractKotlinNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractRustNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractPhpNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractCsharpNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractJavaNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;