gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/named-bindings/types.js

@@ -1,6 +0,0 @@
-/**
- * Named binding types — shared across all per-language binding extractors.
- *
- * Extracted from import-resolution.ts to co-locate types with their consumers.
- */
-export {};

package/dist/core/ingestion/named-bindings/typescript.d.ts

@@ -1,3 +0,0 @@
-import { type SyntaxNode } from '../utils/ast-helpers.js';
-import type { NamedBinding } from './types.js';
-export declare function extractTsNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/typescript.js

@@ -1,58 +0,0 @@
-import { findChild } from '../utils/ast-helpers.js';
-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;
-}

package/dist/core/ingestion/pipeline-phases/cross-file-impl.d.ts

@@ -1,17 +0,0 @@
-/**
- * Cross-file binding propagation — extracted from pipeline.ts.
- *
- * Seeds downstream files with resolved type bindings from upstream exports.
- * Files are processed in topological import order so upstream bindings
- * are available when downstream files are re-resolved.
- *
- * @module
- */
-import type { createResolutionContext } from '../model/resolution-context.js';
-import { type PipelineProgress } from '../../../_shared/index.js';
-import type { KnowledgeGraph } from '../../graph/types.js';
-/**
- * Cross-file binding propagation.
- * Returns the number of files re-processed.
- */
-export declare function runCrossFileBindingPropagation(graph: KnowledgeGraph, ctx: ReturnType<typeof createResolutionContext>, parseExportedTypeMap: ReadonlyMap<string, ReadonlyMap<string, string>>, allPathSet: ReadonlySet<string>, totalFiles: number, repoPath: string, pipelineStart: number, onProgress: (progress: PipelineProgress) => void): Promise<number>;

package/dist/core/ingestion/pipeline-phases/cross-file-impl.js

@@ -1,209 +0,0 @@
-/**
- * Cross-file binding propagation — extracted from pipeline.ts.
- *
- * Seeds downstream files with resolved type bindings from upstream exports.
- * Files are processed in topological import order so upstream bindings
- * are available when downstream files are re-resolved.
- *
- * @module
- */
-import { processCalls, buildImportedReturnTypes, buildImportedRawReturnTypes, } from '../call-processor.js';
-import { createASTCache } from '../ast-cache.js';
-import { getLanguageFromFilename, } from '../../../_shared/index.js';
-import { readFileContents } from '../filesystem-walker.js';
-import { isLanguageAvailable } from '../../tree-sitter/parser-loader.js';
-import { isRegistryPrimary } from '../registry-primary-flag.js';
-import { topologicalLevelSort } from '../utils/graph-sort.js';
-import { isDev } from '../utils/env.js';
-import { logger } from '../../logger.js';
-/** Max AST trees to keep in LRU cache for cross-file binding propagation. */
-const AST_CACHE_CAP = 50;
-/** Minimum percentage of files that must benefit from cross-file seeding. */
-const CROSS_FILE_SKIP_THRESHOLD = 0.03;
-/** Hard cap on files re-processed during cross-file propagation. */
-const MAX_CROSS_FILE_REPROCESS = 2000;
-/**
- * Cross-file binding propagation.
- * Returns the number of files re-processed.
- */
-export async function runCrossFileBindingPropagation(graph, ctx, parseExportedTypeMap, allPathSet, totalFiles, repoPath, pipelineStart, onProgress) {
-    if (parseExportedTypeMap.size === 0 || ctx.namedImportMap.size === 0)
-        return 0;
-    // Build a local mutable working copy. Per-file re-resolution below mutates
-    // this map (each `processCalls` writes that file's exports back into it so
-    // later iterations in the same level/loop can resolve transitive bindings).
-    // Owning a local copy here keeps `ParseOutput.exportedTypeMap` truly
-    // read-only at the phase boundary — no cast, no shared-mutable handoff.
-    const exportedTypeMap = new Map();
-    for (const [fp, exports] of parseExportedTypeMap) {
-        exportedTypeMap.set(fp, new Map(exports));
-    }
-    const { levels, cycleCount } = topologicalLevelSort(ctx.importMap);
-    if (isDev && cycleCount > 0) {
-        logger.info(`🔄 ${cycleCount} files in import cycles (processed last in undefined order)`);
-    }
-    let filesWithGaps = 0;
-    const gapThreshold = Math.max(1, Math.ceil(totalFiles * CROSS_FILE_SKIP_THRESHOLD));
-    outer: for (const level of levels) {
-        for (const filePath of level) {
-            const imports = ctx.namedImportMap.get(filePath);
-            if (!imports)
-                continue;
-            for (const [, binding] of imports) {
-                const upstream = exportedTypeMap.get(binding.sourcePath);
-                if (upstream?.has(binding.exportedName)) {
-                    filesWithGaps++;
-                    break;
-                }
-                const def = ctx.model.symbols.lookupExactFull(binding.sourcePath, binding.exportedName);
-                if (def?.returnType) {
-                    filesWithGaps++;
-                    break;
-                }
-            }
-            if (filesWithGaps >= gapThreshold)
-                break outer;
-        }
-    }
-    const gapRatio = totalFiles > 0 ? filesWithGaps / totalFiles : 0;
-    if (gapRatio < CROSS_FILE_SKIP_THRESHOLD && filesWithGaps < gapThreshold) {
-        if (isDev) {
-            logger.info(`⏭️ Cross-file re-resolution skipped (${filesWithGaps}/${totalFiles} files, ${(gapRatio * 100).toFixed(1)}% < ${CROSS_FILE_SKIP_THRESHOLD * 100}% threshold)`);
-        }
-        return 0;
-    }
-    // Intentionally reports `phase: 'parsing'` rather than a separate
-    // 'crossFile' phase: cross-file re-resolution is logically a continuation of
-    // the parsing/resolution work and is bucketed under "parsing" in any
-    // telemetry that groups events by phase name. Kept consistent with the
-    // upstream `parse` phase's progress events so the UI shows one continuous
-    // progress segment instead of a phase flicker. If a future change splits
-    // this out into its own phase, also rename `parse-impl.ts` per-chunk
-    // progress events accordingly.
-    onProgress({
-        phase: 'parsing',
-        percent: 82,
-        message: `Cross-file type propagation (${filesWithGaps}+ files)...`,
-        stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
-    });
-    let crossFileResolved = 0;
-    const crossFileStart = Date.now();
-    const astCache = createASTCache(AST_CACHE_CAP);
-    // Compiled query objects keyed by language name. Shared across all processCalls
-    // invocations in this phase so the same tree-sitter query string is only
-    // compiled once per language instead of once per file (O(1) vs O(N)).
-    const compiledQueryCache = new Map();
-    // Snapshot total topological candidates for progress math.  We walk the
-    // levels once more here (fast — no I/O) so we can report meaningful
-    // percentages rather than a frozen display.
-    let totalCandidates = 0;
-    for (const level of levels) {
-        for (const filePath of level) {
-            if (totalCandidates >= MAX_CROSS_FILE_REPROCESS)
-                break;
-            const imports = ctx.namedImportMap.get(filePath);
-            if (!imports)
-                continue;
-            if (!allPathSet.has(filePath))
-                continue;
-            const lang = getLanguageFromFilename(filePath);
-            if (!lang || !isLanguageAvailable(lang))
-                continue;
-            // Registry-primary languages have their call resolution handled by the
-            // scope-resolution pipeline — processCalls skips them immediately. Skip
-            // here too so we avoid the I/O cost (readFileContents) and map-building
-            // overhead for files that would be no-ops anyway.
-            if (isRegistryPrimary(lang))
-                continue;
-            totalCandidates++;
-        }
-        if (totalCandidates >= MAX_CROSS_FILE_REPROCESS)
-            break;
-    }
-    const cappedTotal = Math.min(totalCandidates, MAX_CROSS_FILE_REPROCESS);
-    /** Emit a progress event every PROGRESS_INTERVAL files so the UI stays alive. */
-    const PROGRESS_INTERVAL = 25;
-    for (const level of levels) {
-        const levelCandidates = [];
-        for (const filePath of level) {
-            if (crossFileResolved + levelCandidates.length >= MAX_CROSS_FILE_REPROCESS)
-                break;
-            const imports = ctx.namedImportMap.get(filePath);
-            if (!imports)
-                continue;
-            const seeded = new Map();
-            for (const [localName, binding] of imports) {
-                const upstream = exportedTypeMap.get(binding.sourcePath);
-                if (upstream) {
-                    const type = upstream.get(binding.exportedName);
-                    if (type)
-                        seeded.set(localName, type);
-                }
-            }
-            const importedReturns = buildImportedReturnTypes(filePath, ctx.namedImportMap, ctx.model.symbols);
-            const importedRawReturns = buildImportedRawReturnTypes(filePath, ctx.namedImportMap, ctx.model.symbols);
-            if (seeded.size === 0 && importedReturns.size === 0)
-                continue;
-            if (!allPathSet.has(filePath))
-                continue;
-            const lang = getLanguageFromFilename(filePath);
-            if (!lang || !isLanguageAvailable(lang))
-                continue;
-            // Registry-primary languages have their call resolution handled by the
-            // scope-resolution pipeline — processCalls skips them immediately. Skip
-            // here to avoid readFileContents I/O and map-building for no-op files.
-            if (isRegistryPrimary(lang))
-                continue;
-            levelCandidates.push({ filePath, seeded, importedReturns, importedRawReturns });
-        }
-        if (levelCandidates.length === 0)
-            continue;
-        const levelPaths = levelCandidates.map((c) => c.filePath);
-        const contentMap = await readFileContents(repoPath, levelPaths);
-        for (const { filePath, seeded, importedReturns, importedRawReturns } of levelCandidates) {
-            const content = contentMap.get(filePath);
-            if (!content)
-                continue;
-            const reFile = [{ path: filePath, content }];
-            const bindings = new Map();
-            if (seeded.size > 0)
-                bindings.set(filePath, seeded);
-            const importedReturnTypesMap = new Map();
-            if (importedReturns.size > 0) {
-                importedReturnTypesMap.set(filePath, importedReturns);
-            }
-            const importedRawReturnTypesMap = new Map();
-            if (importedRawReturns.size > 0) {
-                importedRawReturnTypesMap.set(filePath, importedRawReturns);
-            }
-            await processCalls(graph, reFile, astCache, ctx, undefined, exportedTypeMap, bindings.size > 0 ? bindings : undefined, importedReturnTypesMap.size > 0 ? importedReturnTypesMap : undefined, importedRawReturnTypesMap.size > 0 ? importedRawReturnTypesMap : undefined, undefined, undefined, compiledQueryCache);
-            crossFileResolved++;
-            // Emit progress every PROGRESS_INTERVAL files so the UI shows real
-            // movement instead of a frozen display (cross-file can take minutes
-            // on large repos with many cross-file imports).
-            if (crossFileResolved % PROGRESS_INTERVAL === 0 || crossFileResolved === cappedTotal) {
-                const pct = cappedTotal > 0 ? Math.round((crossFileResolved / cappedTotal) * 8) : 0;
-                onProgress({
-                    phase: 'parsing',
-                    percent: 82 + pct,
-                    message: `Cross-file type propagation (${crossFileResolved}/${cappedTotal} files)...`,
-                    stats: { filesProcessed: crossFileResolved, totalFiles, nodesCreated: graph.nodeCount },
-                });
-            }
-        }
-        if (crossFileResolved >= MAX_CROSS_FILE_REPROCESS) {
-            if (isDev)
-                logger.info(`⚠️ Cross-file re-resolution capped at ${MAX_CROSS_FILE_REPROCESS} files`);
-            break;
-        }
-    }
-    astCache.clear();
-    if (isDev) {
-        const elapsed = Date.now() - crossFileStart;
-        const totalElapsed = Date.now() - pipelineStart;
-        const reResolutionPct = totalElapsed > 0 ? ((elapsed / totalElapsed) * 100).toFixed(1) : '0';
-        logger.info(`🔗 Cross-file re-resolution: ${crossFileResolved} candidates re-processed` +
-            ` in ${elapsed}ms (${reResolutionPct}% of total ingestion time so far)`);
-    }
-    return crossFileResolved;
-}

package/dist/core/ingestion/pipeline-phases/orm-extraction.d.ts

@@ -1,22 +0,0 @@
-/**
- * Inline ORM query extraction (sequential fallback path).
- *
- * Extracts Prisma and Supabase query calls from source content using
- * regex patterns. Used by the sequential parse path when workers are
- * not available — the worker path extracts ORM queries via tree-sitter
- * queries instead.
- *
- * @module
- */
-import type { ExtractedORMQuery } from '../workers/parse-worker.js';
-/**
- * Extract ORM query calls from file content using regex.
- *
- * Fast-path: skips files that don't contain `prisma.` or `supabase.from`.
- * Results are appended to the `out` array (push pattern avoids allocation).
- *
- * @param filePath  Relative path of the source file
- * @param content   File content string
- * @param out       Output array to append extracted queries to
- */
-export declare function extractORMQueriesInline(filePath: string, content: string, out: ExtractedORMQuery[]): void;

package/dist/core/ingestion/pipeline-phases/orm-extraction.js

@@ -1,92 +0,0 @@
-/**
- * Inline ORM query extraction (sequential fallback path).
- *
- * Extracts Prisma and Supabase query calls from source content using
- * regex patterns. Used by the sequential parse path when workers are
- * not available — the worker path extracts ORM queries via tree-sitter
- * queries instead.
- *
- * @module
- */
-// ── Regex patterns ─────────────────────────────────────────────────────────
-/** Matches Prisma client method calls: `prisma.user.findMany(...)` */
-const PRISMA_QUERY_RE = /\bprisma\.(\w+)\.(findMany|findFirst|findUnique|findUniqueOrThrow|findFirstOrThrow|create|createMany|update|updateMany|delete|deleteMany|upsert|count|aggregate|groupBy)\s*\(/g;
-/** Matches Supabase client method calls: `supabase.from('users').select(...)` */
-const SUPABASE_QUERY_RE = /\bsupabase\.from\s*\(\s*['"](\w+)['"]\s*\)\s*\.(select|insert|update|delete|upsert)\s*\(/g;
-// ── Extraction function ───────────────────────────────────────────────────
-/**
- * Extract ORM query calls from file content using regex.
- *
- * Fast-path: skips files that don't contain `prisma.` or `supabase.from`.
- * Results are appended to the `out` array (push pattern avoids allocation).
- *
- * @param filePath  Relative path of the source file
- * @param content   File content string
- * @param out       Output array to append extracted queries to
- */
-export function extractORMQueriesInline(filePath, content, out) {
-    const hasPrisma = content.includes('prisma.');
-    const hasSupabase = content.includes('supabase.from');
-    if (!hasPrisma && !hasSupabase)
-        return;
-    // Pre-compute line number offsets to avoid O(n²) substring+split per match
-    const lineOffsets = buildLineOffsets(content);
-    if (hasPrisma) {
-        PRISMA_QUERY_RE.lastIndex = 0;
-        let m;
-        while ((m = PRISMA_QUERY_RE.exec(content)) !== null) {
-            const model = m[1];
-            if (model.startsWith('$'))
-                continue;
-            out.push({
-                filePath,
-                orm: 'prisma',
-                model,
-                method: m[2],
-                lineNumber: lineNumberAtOffset(lineOffsets, m.index),
-            });
-        }
-    }
-    if (hasSupabase) {
-        SUPABASE_QUERY_RE.lastIndex = 0;
-        let m;
-        while ((m = SUPABASE_QUERY_RE.exec(content)) !== null) {
-            out.push({
-                filePath,
-                orm: 'supabase',
-                model: m[1],
-                method: m[2],
-                lineNumber: lineNumberAtOffset(lineOffsets, m.index),
-            });
-        }
-    }
-}
-// ── Line offset helpers ───────────────────────────────────────────────────
-/** Build an array of byte offsets where each newline occurs (O(n) once). */
-function buildLineOffsets(content) {
-    const offsets = [];
-    for (let i = 0; i < content.length; i++) {
-        if (content[i] === '\n')
-            offsets.push(i);
-    }
-    return offsets;
-}
-/**
- * Binary search for 0-based line number at a given character offset.
- *
- * Returns the number of newlines that occur before `offset` in the content,
- * which is the 0-based line number. When `offset` is beyond the last newline,
- * returns `lineOffsets.length` (i.e., the last line index).
- */
-function lineNumberAtOffset(lineOffsets, offset) {
-    let lo = 0;
-    let hi = lineOffsets.length;
-    while (lo < hi) {
-        const mid = (lo + hi) >>> 1;
-        if (lineOffsets[mid] < offset)
-            lo = mid + 1;
-        else
-            hi = mid;
-    }
-    return lo;
-}

package/dist/core/ingestion/pipeline-phases/wildcard-synthesis.d.ts

@@ -1,70 +0,0 @@
-/**
- * Wildcard import binding synthesis.
- *
- * Languages with whole-module import semantics (Go, Ruby, C/C++, Swift)
- * import all exported symbols from a file, not specific named symbols.
- * After parsing, we know which symbols each file exports (via graph
- * `isExported`), so we can expand IMPORTS edges into per-symbol bindings
- * that the cross-file propagation phase can use for type resolution.
- *
- * Also builds Python module-alias maps for namespace-import languages
- * (`import models` → `models.User()` resolves to `models.py:User`).
- *
- * @module
- */
-import type { KnowledgeGraph } from '../../graph/types.js';
-import type { createResolutionContext } from '../model/resolution-context.js';
-import type { SupportedLanguages } from '../../../_shared/index.js';
-/** Check if a language uses wildcard (whole-module) import semantics. */
-export declare function isWildcardImportLanguage(lang: SupportedLanguages): boolean;
-/** Check if a language needs synthesis before call resolution.
- *  True for wildcard-import languages AND namespace-import languages (Python). */
-export declare function needsSynthesis(lang: SupportedLanguages): boolean;
-/**
- * Strategy implementation for `importSemantics: 'wildcard-transitive'` (C, C++).
- *
- * Textual-include languages chain symbols through files: if `dict.c` includes
- * `server.h` and `server.h` includes `dict.h`, then `dict.c` sees symbols from
- * all three files. This helper walks the include graph (combining both the
- * ingestion-context `importMap` and the graph-level IMPORTS edges) until the
- * closure is stable.
- *
- * **Order matters.** The returned `Set` preserves iteration order (insertion
- * order). `synthesizeWildcardImportBindings` dedupes bindings by symbol name
- * on a first-seen-wins basis, so this closure's ordering determines which
- * declaration wins when multiple headers export the same name (e.g. overloaded
- * free functions like `write_audit()` vs `write_audit(const char*)` in
- * different headers). We therefore:
- *   1. Seed the closure with direct imports in declaration order (matches the
- *      order of `#include` directives in the source file).
- *   2. Use FIFO / true BFS (`queue.shift()`) for transitive expansion, so
- *      closer headers are seen before deeper ones.
- *
- * Cycle-safe: the `closure.has(file)` guard prevents infinite loops on circular
- * header includes, which are valid C/C++ when paired with `#pragma once` or
- * include guards.
- *
- * Size-bounded: the closure is capped at `MAX_TRANSITIVE_CLOSURE_SIZE` files to
- * prevent OOM on pathological codebases (e.g. boost, monoheader kernel code)
- * where one translation unit can transitively reach tens of thousands of
- * headers. Partial closures still yield useful bindings for the cluster of
- * headers closest to the importer, which is what overload resolution and
- * cross-file call resolution care about.
- *
- * Queue implementation: uses a head-index over a growing array (O(1) dequeue)
- * instead of `Array.prototype.shift()` (O(n)) so deep chains stay linear.
- */
-export declare function expandTransitiveIncludeClosure(directImports: Iterable<string>, importMap: ReadonlyMap<string, ReadonlySet<string>>, graphImports: ReadonlyMap<string, ReadonlySet<string>>): Set<string>;
-/**
- * Synthesize namedImportMap entries for languages with whole-module imports.
- *
- * For each file that imports another file via wildcard semantics:
- * 1. Look up all exported symbols from the imported file (via graph nodes)
- * 2. Create synthetic named bindings: `{ name → { sourcePath, exportedName } }`
- * 3. Build Python module-alias maps for namespace-import languages
- *
- * @param graph  The knowledge graph with parsed symbol nodes
- * @param ctx    Resolution context with importMap and namedImportMap
- * @returns      Number of synthetic bindings created
- */
-export declare function synthesizeWildcardImportBindings(graph: KnowledgeGraph, ctx: ReturnType<typeof createResolutionContext>): number;