gitnexus 1.6.6-rc.99 → 1.6.6

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

@@ -1,377 +0,0 @@
-import Parser from 'tree-sitter';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
-import { getProvider, getProviderForFile, providersWithImplicitWiring } from './languages/index.js';
-import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename } from '../../_shared/index.js';
-import { isVerboseIngestionEnabled } from './utils/verbose.js';
-import { yieldToEventLoop } from './utils/event-loop.js';
-import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
-import { getTreeSitterBufferSize } from './constants.js';
-import { loadImportConfigs } from './language-config.js';
-import { buildSuffixIndex } from './import-resolvers/utils.js';
-import { isDev } from './utils/env.js';
-import { isRegistryPrimary } from './registry-primary-flag.js';
-import { logger } from '../logger.js';
-/** Group files by provider (only those with implicit import wiring), then call each wirer
- *  with its own language's files. O(n) over files, O(1) per provider lookup. */
-function wireImplicitImports(files, importMap, addImportEdge, projectConfig) {
-    if (providersWithImplicitWiring.length === 0)
-        return;
-    const grouped = new Map();
-    for (const file of files) {
-        const provider = getProviderForFile(file);
-        if (!provider?.implicitImportWirer)
-            continue;
-        let list = grouped.get(provider);
-        if (!list) {
-            list = [];
-            grouped.set(provider, list);
-        }
-        list.push(file);
-    }
-    for (const [provider, langFiles] of grouped) {
-        if (langFiles.length > 1) {
-            provider.implicitImportWirer(langFiles, importMap, addImportEdge, projectConfig);
-        }
-    }
-}
-// ImportResolutionContext is defined in ./import-resolvers/types.ts — re-exported here for consumers.
-export function buildImportResolutionContext(allPaths) {
-    const allFileList = allPaths;
-    const normalizedFileList = allFileList.map((p) => p.replace(/\\/g, '/'));
-    const allFilePaths = new Set(allFileList);
-    const index = buildSuffixIndex(normalizedFileList, allFileList);
-    return { allFilePaths, allFileList, normalizedFileList, index, resolveCache: new Map() };
-}
-// Config loaders extracted to ./language-config.ts (Phase 2 refactor)
-// Resolver types are in ./import-resolvers/types.ts; named binding types in ./named-bindings/types.ts
-// ============================================================================
-// Import path preprocessing
-// ============================================================================
-/**
- * Clean and preprocess a raw import source text into a resolved import path.
- * Strips quotes/angle brackets (universal) and applies provider-specific
- * transformations (currently only Kotlin wildcard import detection).
- */
-export function preprocessImportPath(sourceText, importNode, provider) {
-    const cleaned = sourceText.replace(/['"<>]/g, '');
-    // Defense-in-depth: reject null bytes and control characters (matches Ruby call-routing pattern)
-    if (!cleaned || cleaned.length > 2048 || /[\x00-\x1f]/.test(cleaned))
-        return null;
-    if (provider.importPathPreprocessor) {
-        return provider.importPathPreprocessor(cleaned, importNode);
-    }
-    return cleaned;
-}
-/** Create IMPORTS edge helpers that share a resolved-count tracker. */
-function createImportEdgeHelpers(graph, importMap) {
-    let totalImportsResolved = 0;
-    const addImportGraphEdge = (filePath, resolvedPath) => {
-        const language = getLanguageFromFilename(filePath);
-        if (language !== null && isRegistryPrimary(language))
-            return;
-        const sourceId = generateId('File', filePath);
-        const targetId = generateId('File', resolvedPath);
-        const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
-        totalImportsResolved++;
-        graph.addRelationship({
-            id: relId,
-            sourceId,
-            targetId,
-            type: 'IMPORTS',
-            confidence: 1.0,
-            reason: '',
-        });
-    };
-    const addImportEdge = (filePath, resolvedPath) => {
-        addImportGraphEdge(filePath, resolvedPath);
-        if (!importMap.has(filePath))
-            importMap.set(filePath, new Set());
-        importMap.get(filePath).add(resolvedPath);
-    };
-    return { addImportEdge, addImportGraphEdge, getResolvedCount: () => totalImportsResolved };
-}
-/**
- * Apply an ImportResult: emit graph edges and update ImportMap/PackageMap.
- * If namedBindings are provided and the import resolves to a single file,
- * also populate the NamedImportMap for precise Tier 2a resolution.
- * Bindings tagged with `isModuleAlias` are routed to moduleAliasMap instead.
- */
-function applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, namedBindings, namedImportMap, moduleAliasMap) {
-    if (!result)
-        return;
-    if (result.kind === 'package' && packageMap) {
-        // Store directory suffix in PackageMap (skip ImportMap expansion)
-        for (const resolvedFile of result.files) {
-            addImportGraphEdge(filePath, resolvedFile);
-        }
-        if (!packageMap.has(filePath))
-            packageMap.set(filePath, new Set());
-        packageMap.get(filePath).add(result.dirSuffix);
-    }
-    else {
-        // 'files' kind, or 'package' without PackageMap — use ImportMap directly
-        const files = result.files;
-        for (const resolvedFile of files) {
-            addImportEdge(filePath, resolvedFile);
-        }
-        // Route module aliases (import X as Y) directly to moduleAliasMap.
-        // These are module-level aliases, not symbol bindings — they don't belong in namedImportMap.
-        if (namedBindings && moduleAliasMap && files.length === 1) {
-            const resolvedFile = files[0];
-            for (const binding of namedBindings) {
-                if (!binding.isModuleAlias)
-                    continue;
-                let aliasMap = moduleAliasMap.get(filePath);
-                if (!aliasMap) {
-                    aliasMap = new Map();
-                    moduleAliasMap.set(filePath, aliasMap);
-                }
-                aliasMap.set(binding.local, resolvedFile);
-            }
-        }
-        // Record named bindings for precise Tier 2a resolution.
-        // If the same local name is imported from multiple files (e.g., Java static imports
-        // of overloaded methods), remove the entry so resolution falls through to Tier 2a
-        // import-scoped which sees all candidates and can apply arity narrowing.
-        if (namedBindings && namedImportMap) {
-            if (!namedImportMap.has(filePath))
-                namedImportMap.set(filePath, new Map());
-            const fileBindings = namedImportMap.get(filePath);
-            if (files.length === 1) {
-                const resolvedFile = files[0];
-                for (const binding of namedBindings) {
-                    if (binding.isModuleAlias)
-                        continue; // already routed to moduleAliasMap
-                    const existing = fileBindings.get(binding.local);
-                    if (existing && existing.sourcePath !== resolvedFile) {
-                        fileBindings.delete(binding.local);
-                    }
-                    else {
-                        fileBindings.set(binding.local, {
-                            sourcePath: resolvedFile,
-                            exportedName: binding.exported,
-                        });
-                    }
-                }
-            }
-            else {
-                // Multi-file resolution (e.g., Rust `use crate::models::{User, Repo}`).
-                // Match each binding to a resolved file by comparing the lowercase binding name
-                // to the file's basename (without extension). If no match, skip the binding.
-                for (const binding of namedBindings) {
-                    if (binding.isModuleAlias)
-                        continue;
-                    const lowerName = binding.exported.toLowerCase();
-                    const matchedFile = files.find((f) => {
-                        const base = f.replace(/\\/g, '/').split('/').pop() ?? '';
-                        const nameWithoutExt = base.substring(0, base.lastIndexOf('.')).toLowerCase();
-                        return nameWithoutExt === lowerName;
-                    });
-                    if (matchedFile) {
-                        const existing = fileBindings.get(binding.local);
-                        if (existing && existing.sourcePath !== matchedFile) {
-                            fileBindings.delete(binding.local);
-                        }
-                        else {
-                            fileBindings.set(binding.local, {
-                                sourcePath: matchedFile,
-                                exportedName: binding.exported,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-// ============================================================================
-// MAIN IMPORT PROCESSOR
-// ============================================================================
-export const processImports = async (graph, files, astCache, ctx, onProgress, repoRoot, allPaths) => {
-    const importMap = ctx.importMap;
-    const packageMap = ctx.packageMap;
-    const namedImportMap = ctx.namedImportMap;
-    const moduleAliasMap = ctx.moduleAliasMap;
-    // Use allPaths (full repo) when available for cross-chunk resolution, else fall back to chunk files
-    const allFileList = allPaths ?? files.map((f) => f.path);
-    const allFilePaths = new Set(allFileList);
-    const parser = await loadParser();
-    const logSkipped = isVerboseIngestionEnabled();
-    const skippedByLang = logSkipped ? new Map() : null;
-    const resolveCache = new Map();
-    // Pre-compute normalized file list once (forward slashes)
-    const normalizedFileList = allFileList.map((p) => p.replace(/\\/g, '/'));
-    // Build suffix index for O(1) lookups
-    const index = buildSuffixIndex(normalizedFileList, allFileList);
-    // Track import statistics
-    let totalImportsFound = 0;
-    // Load language-specific configs once before the file loop
-    const configs = await loadImportConfigs(repoRoot || '');
-    const resolveCtx = {
-        allFilePaths,
-        allFileList,
-        normalizedFileList,
-        index,
-        resolveCache,
-        configs,
-    };
-    const { addImportEdge, addImportGraphEdge, getResolvedCount } = createImportEdgeHelpers(graph, importMap);
-    for (let i = 0; i < files.length; i++) {
-        const file = files[i];
-        onProgress?.(i + 1, files.length);
-        if (i % 20 === 0)
-            await yieldToEventLoop();
-        // 1. Check language support first
-        const language = getLanguageFromFilename(file.path);
-        if (!language)
-            continue;
-        if (!isLanguageAvailable(language)) {
-            if (skippedByLang) {
-                skippedByLang.set(language, (skippedByLang.get(language) ?? 0) + 1);
-            }
-            continue;
-        }
-        const provider = getProvider(language);
-        const queryStr = provider.treeSitterQueries;
-        if (!queryStr)
-            continue;
-        // 2. ALWAYS load the language before querying (parser is stateful)
-        await loadLanguage(language, file.path);
-        // 3. Get AST (Try Cache First)
-        let tree = astCache.get(file.path);
-        let wasReparsed = false;
-        if (!tree) {
-            const parseContent = provider.preprocessSource?.(file.content, file.path) ?? file.content;
-            try {
-                tree = parseSourceSafe(parser, parseContent, undefined, {
-                    bufferSize: getTreeSitterBufferSize(parseContent),
-                });
-            }
-            catch (parseError) {
-                continue;
-            }
-            wasReparsed = true;
-            // Cache re-parsed tree so call/heritage phases get hits
-            astCache.set(file.path, tree);
-        }
-        let query;
-        let matches;
-        try {
-            const lang = parser.getLanguage();
-            query = new Parser.Query(lang, queryStr);
-            matches = query.matches(tree.rootNode);
-        }
-        catch (queryError) {
-            if (isDev) {
-                logger.error({
-                    file: file.path,
-                    language,
-                    err: queryError?.message || queryError,
-                    queryPreview: queryStr.substring(0, 200) + '...',
-                    contentPreview: file.content.substring(0, 300),
-                    astRootType: tree.rootNode?.type,
-                    astHasError: tree.rootNode?.hasError,
-                }, 'tree-sitter query error');
-            }
-            if (wasReparsed)
-                tree.delete?.();
-            continue;
-        }
-        matches.forEach((match) => {
-            const captureMap = {};
-            match.captures.forEach((c) => (captureMap[c.name] = c.node));
-            if (captureMap['import']) {
-                const sourceNode = captureMap['import.source'];
-                if (!sourceNode) {
-                    if (isDev) {
-                        logger.info(`⚠️ Import captured but no source node in ${file.path}`);
-                    }
-                    return;
-                }
-                const rawImportPath = preprocessImportPath(sourceNode.text, captureMap['import'], provider);
-                if (!rawImportPath)
-                    return;
-                totalImportsFound++;
-                const result = provider.importResolver(rawImportPath, file.path, resolveCtx);
-                const extractor = provider.namedBindingExtractor;
-                const bindings = namedImportMap && extractor ? extractor(captureMap['import']) : undefined;
-                applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge, bindings, namedImportMap, moduleAliasMap);
-            }
-            // ---- Language-specific call-as-import routing (Ruby require, etc.) ----
-            if (captureMap['call']) {
-                const callNameNode = captureMap['call.name'];
-                if (callNameNode) {
-                    const routed = provider.callRouter?.(callNameNode.text, captureMap['call']);
-                    if (routed && routed.kind === 'import') {
-                        totalImportsFound++;
-                        const result = provider.importResolver(routed.importPath, file.path, resolveCtx);
-                        applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge);
-                    }
-                }
-            }
-        });
-        // Tree is now owned by the LRU cache — no manual delete needed
-    }
-    wireImplicitImports(allFileList, importMap, addImportEdge, configs);
-    if (skippedByLang && skippedByLang.size > 0) {
-        for (const [lang, count] of skippedByLang.entries()) {
-            logger.warn(`[ingestion] Skipped ${count} ${lang} file(s) in import processing — ${lang} parser not available.`);
-        }
-    }
-    if (isDev) {
-        logger.info(`📊 Import processing complete: ${getResolvedCount()}/${totalImportsFound} imports resolved to graph edges`);
-    }
-};
-// ============================================================================
-// FAST PATH: Resolve pre-extracted imports (no parsing needed)
-// ============================================================================
-export const processImportsFromExtracted = async (graph, files, extractedImports, ctx, onProgress, repoRoot, prebuiltCtx) => {
-    const importMap = ctx.importMap;
-    const packageMap = ctx.packageMap;
-    const namedImportMap = ctx.namedImportMap;
-    const moduleAliasMap = ctx.moduleAliasMap;
-    const importCtx = prebuiltCtx ?? buildImportResolutionContext(files.map((f) => f.path));
-    const { allFilePaths, allFileList, normalizedFileList, index, resolveCache } = importCtx;
-    let totalImportsFound = 0;
-    const configs = await loadImportConfigs(repoRoot || '');
-    const resolveCtx = {
-        allFilePaths,
-        allFileList,
-        normalizedFileList,
-        index,
-        resolveCache,
-        configs,
-    };
-    const { addImportEdge, addImportGraphEdge, getResolvedCount } = createImportEdgeHelpers(graph, importMap);
-    // Group by file for progress reporting (users see file count, not import count)
-    const importsByFile = new Map();
-    for (const imp of extractedImports) {
-        let list = importsByFile.get(imp.filePath);
-        if (!list) {
-            list = [];
-            importsByFile.set(imp.filePath, list);
-        }
-        list.push(imp);
-    }
-    const totalFiles = importsByFile.size;
-    let filesProcessed = 0;
-    for (const [filePath, fileImports] of importsByFile) {
-        filesProcessed++;
-        if (filesProcessed % 100 === 0) {
-            onProgress?.(filesProcessed, totalFiles);
-            await yieldToEventLoop();
-        }
-        for (const imp of fileImports) {
-            totalImportsFound++;
-            const provider = getProvider(imp.language);
-            const result = provider.importResolver(imp.rawImportPath, filePath, resolveCtx);
-            applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, imp.namedBindings, namedImportMap, moduleAliasMap);
-        }
-    }
-    onProgress?.(totalFiles, totalFiles);
-    wireImplicitImports(files.map((f) => f.path), importMap, addImportEdge, configs);
-    if (isDev) {
-        logger.info(`📊 Import processing (fast path): ${getResolvedCount()}/${totalImportsFound} imports resolved to graph edges`);
-    }
-};

package/dist/core/ingestion/model/heritage-map.d.ts

@@ -1,105 +0,0 @@
-/**
- * Heritage Map
- *
- * Unified inheritance data structure built from accumulated
- * {@link ExtractedHeritage} records **after all chunks complete** (between
- * chunk processing and call resolution). Consumes `ExtractedHeritage[]` and
- * resolves type names to nodeIds via `lookupClassByName`, NOT graph-edge
- * queries.
- *
- * Combines two concerns:
- * 1. **Parent/ancestor lookup** (MRO-aware method resolution)
- * 2. **Implementor lookup** (interface dispatch — which files contain
- *    classes implementing a given interface)
- */
-import type { ResolutionContext } from './resolution-context.js';
-import { type SupportedLanguages } from '../../../_shared/index.js';
-export interface ExtractedHeritage {
-    filePath: string;
-    className: string;
-    parentName: string;
-    /** 'extends' | 'implements' | 'trait-impl' | 'include' | 'extend' | 'prepend' */
-    kind: string;
-}
-export interface HeritageResolutionStrategy {
-    /** If set and the parent name matches, force IMPLEMENTS even when the
-     *  symbol is unresolved (e.g. `/^I[A-Z]/` for C# / Java). */
-    readonly interfaceNamePattern?: RegExp;
-    /** Fallback edge for unresolved parents when the name pattern doesn't
-     *  match (Swift uses 'IMPLEMENTS' for protocol conformance). */
-    readonly defaultEdge: 'EXTENDS' | 'IMPLEMENTS';
-}
-/** Callback used by `buildHeritageMap` to look up the resolution strategy
- *  for a given language. Injected by callers so the model module doesn't
- *  depend on `../languages/index.js`. */
-export type HeritageStrategyLookup = (lang: SupportedLanguages) => HeritageResolutionStrategy;
-/**
- * Determine whether a heritage.extends capture is actually an IMPLEMENTS
- * relationship. Consults the symbol table first (authoritative — Tier 1 /
- * Tier 2 resolution); falls back to the injected {@link HeritageResolutionStrategy}
- * heuristics for external symbols not present in the graph.
- */
-export declare const resolveExtendsType: (parentName: string, currentFilePath: string, ctx: ResolutionContext, strategy: HeritageResolutionStrategy) => {
-    type: "EXTENDS" | "IMPLEMENTS";
-    idPrefix: string;
-};
-/**
- * Direct parent entry with the heritage kind that produced it. Preserved
- * so kind-aware consumers (Ruby MRO, see `lookupMethodByOwnerWithMRO`) can
- * walk prepend/include providers in the correct order. Flat-string consumers
- * use `getParents` / `getAncestors` and see only the parent nodeIds.
- */
-export interface ParentEntry {
-    readonly parentId: string;
-    /** 'extends' | 'implements' | 'trait-impl' | 'include' | 'extend' | 'prepend' */
-    readonly kind: string;
-}
-export interface HeritageMap {
-    /** Direct parents of `childNodeId` (extends + implements + trait-impl). */
-    getParents(childNodeId: string): string[];
-    /** Full ancestor chain (BFS, bounded depth, cycle-safe). */
-    getAncestors(childNodeId: string): string[];
-    /**
-     * Direct parents with heritage kind preserved, insertion-ordered. Used by
-     * kind-aware consumers (Ruby MRO) that need to distinguish prepend /
-     * include / extend / extends for walk-order decisions.
-     *
-     * Insertion order mirrors the order `ExtractedHeritage` records were fed
-     * into `buildHeritageMap`, which in turn mirrors tree-sitter match order.
-     * For Ruby, this matches source declaration order for `prepend` / `include`
-     * statements — the MRO walk reverses this (last-declared-first) at the
-     * consumer side.
-     */
-    getParentEntries(childNodeId: string): readonly ParentEntry[];
-    /**
-     * Ordered ancestry for instance method dispatch (Ruby-aware): includes
-     * `extends`, `implements`, `trait-impl`, `include`, `prepend` kinds.
-     * Excludes `extend` (singleton-only). Order is caller-determined in Unit 3.
-     * For non-Ruby callers (first-wins, c3, etc.), this matches `getAncestors`.
-     */
-    getInstanceAncestry(childNodeId: string): readonly ParentEntry[];
-    /**
-     * Ordered ancestry for singleton / class-method dispatch (Ruby-aware):
-     * only `extend` kind parents. For non-Ruby languages this is always empty.
-     */
-    getSingletonAncestry(childNodeId: string): readonly ParentEntry[];
-    /**
-     * File paths of classes that directly implement or extend-as-interface the
-     * given interface/abstract-class **name**. Replaces the standalone
-     * `ImplementorMap` — used by interface-dispatch in call resolution.
-     */
-    getImplementorFiles(interfaceName: string): ReadonlySet<string>;
-}
-/**
- * Build a HeritageMap from accumulated ExtractedHeritage records.
- *
- * Resolves class/interface/struct/trait names to nodeIds via
- * `ctx.model.types.lookupClassByName`. When a name resolves to multiple
- * candidates, all are recorded (partial-class / cross-file scenario).
- * Unresolvable names are silently skipped — a missing parent is better
- * than a wrong edge.
- *
- * Also builds the implementor index (interface name → implementing file
- * paths) used by interface-dispatch in call resolution.
- */
-export declare const buildHeritageMap: (heritage: readonly ExtractedHeritage[], ctx: ResolutionContext, getHeritageStrategy?: HeritageStrategyLookup) => HeritageMap;