@saluzi/codegraph 0.1.0 → 0.2.0

package/dist/resolution/lru-cache.d.ts

@@ -1,24 +0,0 @@
-/**
- * Simple LRU cache backed by JavaScript's insertion-ordered Map.
- *
- * Used by ReferenceResolver to bound the per-resolver caches that
- * previously grew without limit and OOM'd on large codebases (20k+
- * files). Each cache is sized independently — see `index.ts` for
- * the chosen limits per cache type.
- *
- * Eviction is plain LRU: on `set`, if the cache is full, the
- * least-recently-used entry (the first one in iteration order) is
- * evicted. Touching via `get` moves the entry to the most-recently-used
- * position so hot keys survive eviction passes.
- */
-export declare class LRUCache<K, V> {
-  private readonly max
-  private readonly store
-  constructor(max: number)
-  get size(): number
-  get(key: K): V | undefined
-  has(key: K): boolean
-  set(key: K, value: V): void
-  clear(): void
-}
-//# sourceMappingURL=lru-cache.d.ts.map

package/dist/resolution/lru-cache.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LRUCache = void 0;
-/**
- * Simple LRU cache backed by JavaScript's insertion-ordered Map.
- *
- * Used by ReferenceResolver to bound the per-resolver caches that
- * previously grew without limit and OOM'd on large codebases (20k+
- * files). Each cache is sized independently — see `index.ts` for
- * the chosen limits per cache type.
- *
- * Eviction is plain LRU: on `set`, if the cache is full, the
- * least-recently-used entry (the first one in iteration order) is
- * evicted. Touching via `get` moves the entry to the most-recently-used
- * position so hot keys survive eviction passes.
- */
-class LRUCache {
-    max;
-    store = new Map();
-    constructor(max) {
-        if (!Number.isFinite(max) || max <= 0) {
-            throw new Error(`LRUCache max must be a positive finite number, got ${max}`);
-        }
-        this.max = Math.floor(max);
-    }
-    get size() {
-        return this.store.size;
-    }
-    get(key) {
-        const value = this.store.get(key);
-        if (value === undefined) {
-            // Distinguish "missing" from "stored undefined" by checking has().
-            // We don't store undefined in practice, but be defensive.
-            return this.store.has(key) ? value : undefined;
-        }
-        // Refresh recency by re-inserting.
-        this.store.delete(key);
-        this.store.set(key, value);
-        return value;
-    }
-    has(key) {
-        return this.store.has(key);
-    }
-    set(key, value) {
-        if (this.store.has(key)) {
-            this.store.delete(key);
-        }
-        else if (this.store.size >= this.max) {
-            // Evict the oldest entry — first key in iteration order.
-            const oldest = this.store.keys().next().value;
-            if (oldest !== undefined) {
-                this.store.delete(oldest);
-            }
-        }
-        this.store.set(key, value);
-    }
-    clear() {
-        this.store.clear();
-    }
-}
-exports.LRUCache = LRUCache;
-//# sourceMappingURL=lru-cache.js.map

package/dist/resolution/name-matcher.d.ts

@@ -1,50 +0,0 @@
-/**
- * Name Matcher
- *
- * Handles symbol name matching for reference resolution.
- */
-import { UnresolvedRef, ResolvedRef, ResolutionContext } from './types'
-/**
- * Try to resolve a path-like reference (e.g., "snippets/drawer-menu.liquid")
- * by matching the filename against file nodes.
- */
-export declare function matchByFilePath(
-  ref: UnresolvedRef,
-  context: ResolutionContext,
-): ResolvedRef | null
-/**
- * Try to resolve a reference by exact name match
- */
-export declare function matchByExactName(
-  ref: UnresolvedRef,
-  context: ResolutionContext,
-): ResolvedRef | null
-/**
- * Try to resolve by qualified name
- */
-export declare function matchByQualifiedName(
-  ref: UnresolvedRef,
-  context: ResolutionContext,
-): ResolvedRef | null
-/**
- * Try to resolve by method name on a class/object
- */
-export declare function matchMethodCall(
-  ref: UnresolvedRef,
-  context: ResolutionContext,
-): ResolvedRef | null
-/**
- * Fuzzy match - last resort with lower confidence
- */
-export declare function matchFuzzy(
-  ref: UnresolvedRef,
-  context: ResolutionContext,
-): ResolvedRef | null
-/**
- * Match all strategies in order of confidence
- */
-export declare function matchReference(
-  ref: UnresolvedRef,
-  context: ResolutionContext,
-): ResolvedRef | null
-//# sourceMappingURL=name-matcher.d.ts.map

package/dist/resolution/name-matcher.js

@@ -1,384 +0,0 @@
-"use strict";
-/**
- * Name Matcher
- *
- * Handles symbol name matching for reference resolution.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchByFilePath = matchByFilePath;
-exports.matchByExactName = matchByExactName;
-exports.matchByQualifiedName = matchByQualifiedName;
-exports.matchMethodCall = matchMethodCall;
-exports.matchFuzzy = matchFuzzy;
-exports.matchReference = matchReference;
-/**
- * Try to resolve a path-like reference (e.g., "snippets/drawer-menu.liquid")
- * by matching the filename against file nodes.
- */
-function matchByFilePath(ref, context) {
-    if (!ref.referenceName.includes('/'))
-        return null;
-    // Extract the filename from the path
-    const fileName = ref.referenceName.split('/').pop();
-    if (!fileName)
-        return null;
-    // Search for file nodes with this name
-    const candidates = context.getNodesByName(fileName);
-    const fileNodes = candidates.filter(n => n.kind === 'file');
-    if (fileNodes.length === 0)
-        return null;
-    // Prefer exact path match on qualified_name
-    const exactMatch = fileNodes.find(n => n.qualifiedName === ref.referenceName || n.filePath === ref.referenceName);
-    if (exactMatch) {
-        return {
-            original: ref,
-            targetNodeId: exactMatch.id,
-            confidence: 0.95,
-            resolvedBy: 'file-path',
-        };
-    }
-    // Fall back to suffix match (e.g., ref="snippets/foo.liquid" matches "src/snippets/foo.liquid")
-    const suffixMatch = fileNodes.find(n => n.qualifiedName.endsWith(ref.referenceName) || n.filePath.endsWith(ref.referenceName));
-    if (suffixMatch) {
-        return {
-            original: ref,
-            targetNodeId: suffixMatch.id,
-            confidence: 0.85,
-            resolvedBy: 'file-path',
-        };
-    }
-    // If only one file node with this name, use it with lower confidence
-    if (fileNodes.length === 1) {
-        return {
-            original: ref,
-            targetNodeId: fileNodes[0].id,
-            confidence: 0.7,
-            resolvedBy: 'file-path',
-        };
-    }
-    return null;
-}
-/**
- * Try to resolve a reference by exact name match
- */
-function matchByExactName(ref, context) {
-    const candidates = context.getNodesByName(ref.referenceName);
-    if (candidates.length === 0) {
-        return null;
-    }
-    // If only one match, use it — but penalize cross-language matches
-    if (candidates.length === 1) {
-        const isCrossLanguage = candidates[0].language !== ref.language;
-        return {
-            original: ref,
-            targetNodeId: candidates[0].id,
-            confidence: isCrossLanguage ? 0.5 : 0.9,
-            resolvedBy: 'exact-match',
-        };
-    }
-    // Multiple matches - try to narrow down
-    const bestMatch = findBestMatch(ref, candidates, context);
-    if (bestMatch) {
-        // Lower confidence when the match is from a distant/unrelated module
-        const proximity = computePathProximity(ref.filePath, bestMatch.filePath);
-        const confidence = proximity >= 30 ? 0.7 : 0.4;
-        return {
-            original: ref,
-            targetNodeId: bestMatch.id,
-            confidence,
-            resolvedBy: 'exact-match',
-        };
-    }
-    return null;
-}
-/**
- * Try to resolve by qualified name
- */
-function matchByQualifiedName(ref, context) {
-    // Check if the reference name looks qualified (contains :: or .)
-    if (!ref.referenceName.includes('::') && !ref.referenceName.includes('.')) {
-        return null;
-    }
-    const candidates = context.getNodesByQualifiedName(ref.referenceName);
-    if (candidates.length === 1) {
-        return {
-            original: ref,
-            targetNodeId: candidates[0].id,
-            confidence: 0.95,
-            resolvedBy: 'qualified-name',
-        };
-    }
-    // Try partial qualified name match
-    const parts = ref.referenceName.split(/[:.]/);
-    const lastName = parts[parts.length - 1];
-    if (lastName) {
-        const partialCandidates = context.getNodesByName(lastName);
-        for (const candidate of partialCandidates) {
-            if (candidate.qualifiedName.endsWith(ref.referenceName)) {
-                return {
-                    original: ref,
-                    targetNodeId: candidate.id,
-                    confidence: 0.85,
-                    resolvedBy: 'qualified-name',
-                };
-            }
-        }
-    }
-    return null;
-}
-/**
- * Try to resolve by method name on a class/object
- */
-function matchMethodCall(ref, context) {
-    // Parse method call patterns like "obj.method" or "Class::method"
-    const dotMatch = ref.referenceName.match(/^(\w+)\.(\w+)$/);
-    const colonMatch = ref.referenceName.match(/^(\w+)::(\w+)$/);
-    const match = dotMatch || colonMatch;
-    if (!match) {
-        return null;
-    }
-    const [, objectOrClass, methodName] = match;
-    // Strategy 1: Direct class name match (existing logic)
-    const classCandidates = context.getNodesByName(objectOrClass);
-    for (const classNode of classCandidates) {
-        if (classNode.kind === 'class' || classNode.kind === 'struct' || classNode.kind === 'interface') {
-            // Skip cross-language class matches
-            if (classNode.language !== ref.language)
-                continue;
-            const nodesInFile = context.getNodesInFile(classNode.filePath);
-            const methodNode = nodesInFile.find((n) => n.kind === 'method' &&
-                n.name === methodName &&
-                n.qualifiedName.includes(classNode.name));
-            if (methodNode) {
-                return {
-                    original: ref,
-                    targetNodeId: methodNode.id,
-                    confidence: 0.85,
-                    resolvedBy: 'qualified-name',
-                };
-            }
-        }
-    }
-    // Strategy 2: Instance variable receiver - try capitalized form to find class
-    // e.g., "permissionEngine" → look for classes containing "PermissionEngine"
-    const capitalizedReceiver = objectOrClass.charAt(0).toUpperCase() + objectOrClass.slice(1);
-    if (capitalizedReceiver !== objectOrClass) {
-        const fuzzyClassCandidates = context.getNodesByName(capitalizedReceiver);
-        for (const classNode of fuzzyClassCandidates) {
-            if (classNode.kind === 'class' || classNode.kind === 'struct' || classNode.kind === 'interface') {
-                // Skip cross-language class matches
-                if (classNode.language !== ref.language)
-                    continue;
-                const nodesInFile = context.getNodesInFile(classNode.filePath);
-                const methodNode = nodesInFile.find((n) => n.kind === 'method' &&
-                    n.name === methodName &&
-                    n.qualifiedName.includes(classNode.name));
-                if (methodNode) {
-                    return {
-                        original: ref,
-                        targetNodeId: methodNode.id,
-                        confidence: 0.8,
-                        resolvedBy: 'instance-method',
-                    };
-                }
-            }
-        }
-    }
-    // Strategy 3: Find methods by name across the codebase, match by receiver
-    // name similarity with the containing class. Handles abbreviated variable
-    // names like permissionEngine → PermissionRuleEngine.
-    if (methodName) {
-        const methodCandidates = context.getNodesByName(methodName);
-        const methods = methodCandidates.filter((n) => n.kind === 'method' && n.name === methodName);
-        // Filter to same-language candidates first
-        const sameLanguageMethods = methods.filter(m => m.language === ref.language);
-        const targetMethods = sameLanguageMethods.length > 0 ? sameLanguageMethods : methods;
-        // If only one same-language method with this name exists, use it
-        if (targetMethods.length === 1 && targetMethods[0].language === ref.language) {
-            return {
-                original: ref,
-                targetNodeId: targetMethods[0].id,
-                confidence: 0.7,
-                resolvedBy: 'instance-method',
-            };
-        }
-        // Multiple methods: score by receiver name word overlap with class name
-        if (targetMethods.length > 1) {
-            const receiverWords = splitCamelCase(objectOrClass);
-            let bestMatch;
-            let bestScore = 0;
-            for (const method of targetMethods) {
-                const classWords = splitCamelCase(method.qualifiedName);
-                let score = receiverWords.filter(w => classWords.some(cw => cw.toLowerCase() === w.toLowerCase())).length;
-                // Bonus for same language
-                if (method.language === ref.language)
-                    score += 1;
-                if (score > bestScore) {
-                    bestScore = score;
-                    bestMatch = method;
-                }
-            }
-            if (bestMatch && bestScore >= 2) {
-                return {
-                    original: ref,
-                    targetNodeId: bestMatch.id,
-                    confidence: 0.65,
-                    resolvedBy: 'instance-method',
-                };
-            }
-        }
-    }
-    return null;
-}
-/**
- * Split a camelCase or PascalCase string into words.
- */
-function splitCamelCase(str) {
-    return str.replace(/([a-z])([A-Z])/g, '$1 $2')
-        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
-        .split(/[\s._:\/\\]+/)
-        .filter(w => w.length > 1);
-}
-/**
- * Compute directory proximity between two file paths.
- * Returns a score based on the number of shared directory segments.
- * Higher score = closer in directory tree.
- */
-function computePathProximity(filePath1, filePath2) {
-    const dir1 = filePath1.split('/').slice(0, -1);
-    const dir2 = filePath2.split('/').slice(0, -1);
-    let shared = 0;
-    for (let i = 0; i < Math.min(dir1.length, dir2.length); i++) {
-        if (dir1[i] === dir2[i]) {
-            shared++;
-        }
-        else {
-            break;
-        }
-    }
-    // Each shared directory segment contributes 15 points, capped at 80
-    return Math.min(shared * 15, 80);
-}
-/**
- * Find the best matching node when there are multiple candidates
- */
-function findBestMatch(ref, candidates, _context) {
-    // Prioritization rules:
-    // 1. Same file > different file
-    // 2. Directory proximity (same module/package > different module)
-    // 3. Same language > different language
-    // 4. Functions/methods > classes/types (for call references)
-    // 5. Exported > non-exported
-    let bestScore = -1;
-    let bestNode = null;
-    for (const candidate of candidates) {
-        let score = 0;
-        // Same file bonus
-        if (candidate.filePath === ref.filePath) {
-            score += 100;
-        }
-        // Directory proximity bonus — strongly prefer same module/package
-        score += computePathProximity(ref.filePath, candidate.filePath);
-        // Language matching: strongly prefer same language, penalize cross-language
-        if (candidate.language === ref.language) {
-            score += 50;
-        }
-        else {
-            score -= 80;
-        }
-        // For call references, prefer functions/methods
-        if (ref.referenceKind === 'calls') {
-            if (candidate.kind === 'function' || candidate.kind === 'method') {
-                score += 25;
-            }
-        }
-        // For instantiation references (`new Foo()`), prefer class-like
-        // targets — without this, a function named `Foo` in another module
-        // could outscore the actual class.
-        if (ref.referenceKind === 'instantiates') {
-            if (candidate.kind === 'class' ||
-                candidate.kind === 'struct' ||
-                candidate.kind === 'interface') {
-                score += 25;
-            }
-        }
-        // For decorator references (`@Foo`), prefer functions. Class
-        // decorators (Python `@SomeClass`, Java annotation interfaces)
-        // also resolve here, hence the smaller class bonus.
-        if (ref.referenceKind === 'decorates') {
-            if (candidate.kind === 'function' || candidate.kind === 'method') {
-                score += 25;
-            }
-            else if (candidate.kind === 'class' || candidate.kind === 'interface') {
-                score += 15;
-            }
-        }
-        // Exported bonus
-        if (candidate.isExported) {
-            score += 10;
-        }
-        // Closer line number (within same file)
-        if (candidate.filePath === ref.filePath && candidate.startLine) {
-            const distance = Math.abs(candidate.startLine - ref.line);
-            score += Math.max(0, 20 - distance / 10);
-        }
-        if (score > bestScore) {
-            bestScore = score;
-            bestNode = candidate;
-        }
-    }
-    return bestNode;
-}
-/**
- * Fuzzy match - last resort with lower confidence
- */
-function matchFuzzy(ref, context) {
-    const lowerName = ref.referenceName.toLowerCase();
-    // Use pre-built lowercase index for O(1) lookup instead of scanning all nodes
-    const candidates = context.getNodesByLowerName(lowerName);
-    // Filter to callable kinds only (function, method, class)
-    const callableKinds = new Set(['function', 'method', 'class']);
-    const callableCandidates = candidates.filter((n) => callableKinds.has(n.kind));
-    // Prefer same-language matches
-    const sameLanguageCandidates = callableCandidates.filter(n => n.language === ref.language);
-    const finalCandidates = sameLanguageCandidates.length > 0 ? sameLanguageCandidates : callableCandidates;
-    if (finalCandidates.length === 1) {
-        const isCrossLanguage = finalCandidates[0].language !== ref.language;
-        return {
-            original: ref,
-            targetNodeId: finalCandidates[0].id,
-            confidence: isCrossLanguage ? 0.3 : 0.5,
-            resolvedBy: 'fuzzy',
-        };
-    }
-    return null;
-}
-/**
- * Match all strategies in order of confidence
- */
-function matchReference(ref, context) {
-    // Try strategies in order of confidence
-    let result;
-    // 0. File path match (e.g., "snippets/drawer-menu.liquid" → file node)
-    result = matchByFilePath(ref, context);
-    if (result)
-        return result;
-    // 1. Qualified name match (highest confidence)
-    result = matchByQualifiedName(ref, context);
-    if (result)
-        return result;
-    // 2. Method call pattern
-    result = matchMethodCall(ref, context);
-    if (result)
-        return result;
-    // 3. Exact name match
-    result = matchByExactName(ref, context);
-    if (result)
-        return result;
-    // 4. Fuzzy match (lowest confidence)
-    result = matchFuzzy(ref, context);
-    if (result)
-        return result;
-    return null;
-}
-//# sourceMappingURL=name-matcher.js.map

package/dist/resolution/path-aliases.d.ts

@@ -1,72 +0,0 @@
-/**
- * Project-level import-path alias loading.
- *
- * Reads `compilerOptions.paths` from `tsconfig.json` / `jsconfig.json`
- * at the project root and converts the patterns into a form the
- * import-resolver can consult.
- *
- * This is the single biggest blocker to accurate resolution on modern
- * JS/TS codebases: aliases like `@/components/Foo` (Next, Nuxt, Nest,
- * Vite scaffolds) point into a `paths` map the resolver previously
- * ignored — every import through an alias was treated as unresolvable
- * unless it happened to match the small hard-coded fallback list.
- *
- * Scope deliberately small for v1:
- *   - reads tsconfig.json, then jsconfig.json
- *   - honours top-level `compilerOptions.baseUrl` and `compilerOptions.paths`
- *   - supports `*` wildcard (the only TS-supported wildcard)
- *   - does NOT follow `extends` chains yet (most projects don't need it)
- *   - does NOT read Vite/webpack/Rollup configs (separate follow-up)
- *
- * The file is parsed as JSON-with-comments-tolerant — tsconfigs in the
- * wild routinely contain `//` and `/* *\/` comments and trailing
- * commas, which JSON.parse rejects. We strip those before parsing.
- */
-/** A single alias pattern from `compilerOptions.paths`. */
-export interface AliasPattern {
-  /** The literal prefix before `*` (or the whole pattern if no `*`). */
-  prefix: string
-  /** The literal suffix after `*` (almost always empty). */
-  suffix: string
-  /** Whether the pattern contains a `*` wildcard. */
-  hasWildcard: boolean
-  /**
-   * Replacement templates. When `hasWildcard` is true, `*` in the
-   * replacement is filled with the captured wildcard portion of the
-   * import path. Stored relative to {@link AliasMap.baseUrl}.
-   * tsconfig allows multiple targets per alias (priority order).
-   */
-  replacements: string[]
-}
-export interface AliasMap {
-  /** Absolute path. The directory `compilerOptions.paths` is rooted at. */
-  baseUrl: string
-  /**
-   * Patterns ordered by specificity: longer prefix first, then literal-
-   * before-wildcard, so the resolver tries the most-specific match.
-   */
-  patterns: AliasPattern[]
-}
-/**
- * Load aliases for `projectRoot`. Returns `null` when no tsconfig /
- * jsconfig is present or when the file has no usable `paths`.
- *
- * Cheap to call repeatedly — caching is the caller's job (the
- * resolver does it via {@link aliasCache}).
- */
-export declare function loadProjectAliases(projectRoot: string): AliasMap | null
-/**
- * Resolve an import path through an {@link AliasMap}. Returns the list
- * of candidate filesystem paths (relative to `projectRoot`), in the
- * priority order defined by tsconfig (multiple replacements per alias
- * are tried in order). Returns `[]` when no alias matches.
- *
- * Callers still need to try each candidate with the language's
- * extension list — this function only does the alias rewrite.
- */
-export declare function applyAliases(
-  importPath: string,
-  aliases: AliasMap,
-  projectRoot: string,
-): string[]
-//# sourceMappingURL=path-aliases.d.ts.map