gitnexus 1.5.2 → 1.6.0

package/dist/storage/git.js

@@ -52,3 +52,28 @@ export const hasGitDir = (dirPath) => {
         return false;
     }
 };
+/**
+ * Parse unified diff output (with -U0) into per-file hunk ranges.
+ * Extracts the new-file line ranges from @@ hunk headers.
+ */
+export function parseDiffHunks(diffOutput) {
+    const files = [];
+    let current = null;
+    for (const line of diffOutput.split('\n')) {
+        if (line.startsWith('+++ b/')) {
+            current = { filePath: line.slice(6), hunks: [] };
+            files.push(current);
+        }
+        else if (line.startsWith('@@') && current) {
+            const match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+            if (match) {
+                const start = parseInt(match[1], 10);
+                const count = match[2] !== undefined ? parseInt(match[2], 10) : 1;
+                if (count > 0) {
+                    current.hunks.push({ startLine: start, endLine: start + count - 1 });
+                }
+            }
+        }
+    }
+    return files;
+}

package/dist/storage/repo-manager.js

@@ -167,7 +167,7 @@ export const addToGitignore = async (repoPath) => {
  * Get the path to the global GitNexus directory
  */
 export const getGlobalDir = () => {
-    return path.join(os.homedir(), '.gitnexus');
+    return process.env.GITNEXUS_HOME || path.join(os.homedir(), '.gitnexus');
 };
 /**
  * Get the path to the global registry file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.5.2",
+  "version": "1.6.0",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",
@@ -46,6 +46,7 @@
     "test:integration": "vitest run test/integration",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
+    "postinstall": "node scripts/patch-tree-sitter-swift.cjs",
     "prepare": "node scripts/build.js",
     "prepack": "node scripts/build.js"
   },
@@ -53,15 +54,18 @@
     "@huggingface/transformers": "^3.0.0",
     "@ladybugdb/core": "^0.15.2",
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "@scarf/scarf": "^1.4.0",
     "cli-progress": "^3.12.0",
     "commander": "^12.0.0",
     "cors": "^2.8.5",
     "express": "^4.19.2",
+    "gitnexus-shared": "file:../gitnexus-shared",
     "glob": "^11.0.0",
     "graphology": "^0.25.4",
     "graphology-indices": "^0.17.0",
     "graphology-utils": "^2.3.0",
     "ignore": "^7.0.5",
+    "js-yaml": "^4.1.1",
     "lru-cache": "^11.0.0",
     "mnemonist": "^0.39.0",
     "onnxruntime-node": "^1.24.0",
@@ -90,6 +94,7 @@
     "@types/cli-progress": "^3.11.6",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.0.0",
     "@types/uuid": "^10.0.0",
     "@vitest/coverage-v8": "^4.0.18",
@@ -100,7 +105,8 @@
   "overrides": {
     "@huggingface/transformers": {
       "onnxruntime-node": "$onnxruntime-node"
-    }
+    },
+    "tree-sitter-c": "0.23.2"
   },
   "engines": {
     "node": ">=20.0.0"

package/scripts/patch-tree-sitter-swift.cjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * WORKAROUND: tree-sitter-swift@0.6.0 binding.gyp build failure
+ *
+ * Background:
+ *   tree-sitter-swift@0.6.0's binding.gyp contains an "actions" array that
+ *   invokes `tree-sitter generate` to regenerate parser.c from grammar.js.
+ *   This is intended for grammar developers, but the published npm package
+ *   already ships pre-generated parser files (parser.c, scanner.c), so the
+ *   actions are unnecessary for consumers. Since consumers don't have
+ *   tree-sitter-cli installed, the actions always fail during `npm install`.
+ *
+ * Why we can't just upgrade:
+ *   tree-sitter-swift@0.7.1 fixes this (removes postinstall, ships prebuilds),
+ *   but it requires tree-sitter@^0.22.1. The upstream project pins tree-sitter
+ *   to ^0.21.0 and all other grammar packages depend on that version.
+ *   Upgrading tree-sitter would be a separate breaking change.
+ *
+ * How this workaround works:
+ *   1. tree-sitter-swift's own postinstall fails (npm warns but continues)
+ *   2. This script runs as gitnexus's postinstall
+ *   3. It removes the "actions" array from binding.gyp
+ *   4. It rebuilds the native binding with the cleaned binding.gyp
+ *
+ * TODO: Remove this script when tree-sitter is upgraded to ^0.22.x,
+ *       which allows using tree-sitter-swift@0.7.1+ directly.
+ */
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const swiftDir = path.join(__dirname, '..', 'node_modules', 'tree-sitter-swift');
+const bindingPath = path.join(swiftDir, 'binding.gyp');
+
+try {
+  if (!fs.existsSync(bindingPath)) {
+    process.exit(0);
+  }
+
+  const content = fs.readFileSync(bindingPath, 'utf8');
+  let needsRebuild = false;
+
+  if (content.includes('"actions"')) {
+    // Strip Python-style comments (#) and trailing commas before JSON parsing
+    const cleaned = content
+      .replace(/#[^\n]*/g, '') // Remove # comments
+      .replace(/,(\s*[\]}])/g, '$1'); // Remove trailing commas before ] or }
+    const gyp = JSON.parse(cleaned);
+
+    if (gyp.targets && gyp.targets[0] && gyp.targets[0].actions) {
+      delete gyp.targets[0].actions;
+      fs.writeFileSync(bindingPath, JSON.stringify(gyp, null, 2) + '\n');
+      console.log('[tree-sitter-swift] Patched binding.gyp (removed actions array)');
+      needsRebuild = true;
+    }
+  }
+
+  // Check if native binding exists
+  const bindingNode = path.join(swiftDir, 'build', 'Release', 'tree_sitter_swift_binding.node');
+  if (!fs.existsSync(bindingNode)) {
+    needsRebuild = true;
+  }
+
+  if (needsRebuild) {
+    console.log('[tree-sitter-swift] Rebuilding native binding...');
+    execSync('npx node-gyp rebuild', {
+      cwd: swiftDir,
+      stdio: 'pipe',
+      timeout: 120000,
+    });
+    console.log('[tree-sitter-swift] Native binding built successfully');
+  }
+} catch (err) {
+  console.warn('[tree-sitter-swift] Could not build native binding:', err.message);
+  console.warn(
+    '[tree-sitter-swift] You may need to manually run: cd node_modules/tree-sitter-swift && npx node-gyp rebuild',
+  );
+}

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

@@ -1,18 +0,0 @@
-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;

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

@@ -1,42 +0,0 @@
-/**
- * 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;
-}

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,
-    };
-};