@saluzi/codegraph 0.1.0

package/dist/search/query-parser.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * Field-qualified search query parser.
+ *
+ * Splits a raw query like
+ *
+ *     kind:function name:auth path:src/api authenticate
+ *
+ * into structured filters (kind=function, name="auth", path prefix
+ * "src/api") plus the free-text portion ("authenticate") that goes
+ * to FTS. Free-text and filters compose: filters narrow the result
+ * set, FTS scores within the narrowed set.
+ *
+ * Recognised fields (case-insensitive, value is the rest until
+ * whitespace):
+ *
+ *   kind:    one of function|method|class|interface|struct|...
+ *   lang:    one of typescript|python|go|...   (alias: language:)
+ *   path:    case-insensitive substring of file_path
+ *   name:    case-insensitive substring of the symbol's name
+ *
+ * Unknown field prefixes (e.g. `foo:bar`) are passed through to FTS
+ * as plain text — that's how someone searching for `TODO:` gets a
+ * result instead of a parse error.
+ *
+ * Quoting:
+ *   kind:function path:"src/some path/with spaces" → handled by stripping
+ *   the surrounding double quotes from the value (single token only,
+ *   no nested escapes).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQuery = parseQuery;
+exports.boundedEditDistance = boundedEditDistance;
+const types_1 = require("../types");
+// Derived from the canonical `NODE_KINDS` / `LANGUAGES` arrays in
+// types.ts so adding a new kind or language doesn't silently fall
+// through to plain text here.
+const KIND_VALUES = new Set(types_1.NODE_KINDS);
+const LANGUAGE_VALUES = new Set(types_1.LANGUAGES);
+/**
+ * Strip a surrounding pair of double quotes from `s`. Allows users to
+ * keep whitespace in path filters: `path:"my dir/file"`.
+ */
+function unquote(s) {
+    if (s.length >= 2 && s.startsWith('"') && s.endsWith('"'))
+        return s.slice(1, -1);
+    return s;
+}
+/**
+ * Parse a raw query into structured filters + remaining text.
+ * Always returns a value; never throws.
+ */
+function parseQuery(raw) {
+    const out = {
+        text: '',
+        kinds: [],
+        languages: [],
+        pathFilters: [],
+        nameFilters: [],
+    };
+    // Tokenise on whitespace, preserving quoted spans as part of the
+    // current token. Quotes can appear at the start (`"…"`) OR mid-token
+    // (`path:"…"`); in both cases everything from the opening `"` to the
+    // matching `"` is included in the token, whitespace and all.
+    const tokens = [];
+    let i = 0;
+    while (i < raw.length) {
+        while (i < raw.length && /\s/.test(raw[i]))
+            i++;
+        if (i >= raw.length)
+            break;
+        const start = i;
+        while (i < raw.length && !/\s/.test(raw[i])) {
+            if (raw[i] === '"') {
+                const end = raw.indexOf('"', i + 1);
+                if (end === -1) {
+                    // Unterminated quote — swallow the rest of the input as
+                    // one token. Forgiving rather than throwing.
+                    i = raw.length;
+                    break;
+                }
+                i = end + 1;
+                continue;
+            }
+            i++;
+        }
+        tokens.push(raw.slice(start, i));
+    }
+    const textParts = [];
+    for (const tok of tokens) {
+        const colon = tok.indexOf(':');
+        if (colon <= 0 || colon === tok.length - 1) {
+            textParts.push(tok);
+            continue;
+        }
+        const key = tok.slice(0, colon).toLowerCase();
+        const valueRaw = unquote(tok.slice(colon + 1));
+        if (!valueRaw) {
+            textParts.push(tok);
+            continue;
+        }
+        switch (key) {
+            case 'kind': {
+                if (KIND_VALUES.has(valueRaw)) {
+                    out.kinds.push(valueRaw);
+                }
+                else {
+                    textParts.push(tok);
+                }
+                break;
+            }
+            case 'lang':
+            case 'language': {
+                const lower = valueRaw.toLowerCase();
+                if (LANGUAGE_VALUES.has(lower)) {
+                    out.languages.push(lower);
+                }
+                else {
+                    textParts.push(tok);
+                }
+                break;
+            }
+            case 'path':
+                out.pathFilters.push(valueRaw);
+                break;
+            case 'name':
+                out.nameFilters.push(valueRaw);
+                break;
+            default:
+                textParts.push(tok);
+        }
+    }
+    out.text = textParts.join(' ').trim();
+    return out;
+}
+/**
+ * Damerau-Levenshtein-ish bounded edit distance. Returns `maxDist + 1`
+ * as soon as the distance is known to exceed `maxDist`; that early-exit
+ * makes the fuzzy fallback cheap even over tens of thousands of names.
+ *
+ * Pure DP, O(min(len(a), len(b))) memory. Compares case-folded inputs;
+ * callers should pass `lowercase(name)` strings.
+ */
+function boundedEditDistance(a, b, maxDist) {
+    if (a === b)
+        return 0;
+    const al = a.length;
+    const bl = b.length;
+    if (Math.abs(al - bl) > maxDist)
+        return maxDist + 1;
+    if (al === 0)
+        return bl;
+    if (bl === 0)
+        return al;
+    let prev = new Array(bl + 1);
+    let cur = new Array(bl + 1);
+    for (let j = 0; j <= bl; j++)
+        prev[j] = j;
+    for (let i = 1; i <= al; i++) {
+        cur[0] = i;
+        let rowMin = cur[0];
+        for (let j = 1; j <= bl; j++) {
+            const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+            const insertion = cur[j - 1] + 1;
+            const deletion = prev[j] + 1;
+            const substitution = prev[j - 1] + cost;
+            cur[j] = Math.min(insertion, deletion, substitution);
+            if (cur[j] < rowMin)
+                rowMin = cur[j];
+        }
+        if (rowMin > maxDist)
+            return maxDist + 1;
+        [prev, cur] = [cur, prev];
+    }
+    return prev[bl];
+}
+//# sourceMappingURL=query-parser.js.map

package/dist/search/query-utils.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Search Query Utilities
+ *
+ * Shared module for search term extraction and scoring.
+ */
+import { Node } from '../types'
+/**
+ * Common stop words to filter from search queries.
+ * Includes generic English + code-specific noise words.
+ */
+export declare const STOP_WORDS: Set<string>
+/**
+ * Generate stem variants of a search term by removing common English suffixes.
+ * Used for FTS query expansion so "caching" also finds "cache", "eviction" finds "evict", etc.
+ * Stems are used as PREFIX matches in FTS, so they don't need to be perfect English words.
+ */
+export declare function getStemVariants(term: string): string[]
+/**
+ * Extract meaningful search terms from a natural language query.
+ * Splits camelCase, PascalCase, snake_case, SCREAMING_SNAKE, and dot.notation
+ * into individual tokens before filtering.
+ *
+ * Preserves original compound identifiers (e.g., "scrapeLoop") alongside
+ * their split parts so that FTS can match both the full symbol name and
+ * individual words within it.
+ *
+ * Also generates stem variants (e.g., "caching"→"cache", "eviction"→"evict")
+ * so FTS prefix matching can find related code symbols.
+ */
+export declare function extractSearchTerms(
+  query: string,
+  options?: {
+    stems?: boolean
+  },
+): string[]
+/**
+ * Score path relevance to a query
+ * Higher score = more relevant path
+ */
+export declare function scorePathRelevance(
+  filePath: string,
+  query: string,
+): number
+/**
+ * Check if a file path looks like a test file
+ */
+export declare function isTestFile(filePath: string): boolean
+/**
+ * Bonus when a node's name matches the search query.
+ * Exact matches get the largest boost; prefix matches get smaller boosts.
+ * Multi-word queries also check individual term matches against the name.
+ */
+export declare function nameMatchBonus(nodeName: string, query: string): number
+/**
+ * Kind-based bonus for search ranking
+ * Functions and classes are typically more relevant than variables/imports
+ */
+export declare function kindBonus(kind: Node['kind']): number
+//# sourceMappingURL=query-utils.d.ts.map

package/dist/search/query-utils.js

@@ -0,0 +1,383 @@
+"use strict";
+/**
+ * Search Query Utilities
+ *
+ * Shared module for search term extraction and scoring.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STOP_WORDS = void 0;
+exports.getStemVariants = getStemVariants;
+exports.extractSearchTerms = extractSearchTerms;
+exports.scorePathRelevance = scorePathRelevance;
+exports.isTestFile = isTestFile;
+exports.nameMatchBonus = nameMatchBonus;
+exports.kindBonus = kindBonus;
+const path = __importStar(require("path"));
+/**
+ * Common stop words to filter from search queries.
+ * Includes generic English + code-specific noise words.
+ */
+exports.STOP_WORDS = new Set([
+    // English
+    'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+    'of', 'with', 'by', 'from', 'is', 'it', 'that', 'this', 'are', 'was',
+    'be', 'has', 'had', 'have', 'do', 'does', 'did', 'will', 'would', 'could',
+    'should', 'may', 'might', 'can', 'shall', 'not', 'no', 'all', 'each',
+    'every', 'how', 'what', 'where', 'when', 'who', 'which', 'why',
+    'i', 'me', 'my', 'we', 'our', 'you', 'your', 'he', 'she', 'they',
+    'show', 'give', 'tell',
+    'been', 'done', 'made', 'used', 'using', 'work', 'works', 'found',
+    'also', 'into', 'then', 'than', 'just', 'more', 'some', 'such',
+    'over', 'only', 'out', 'its', 'so', 'up', 'as', 'if',
+    'look', 'need', 'needs', 'want', 'happen', 'happens',
+    'affect', 'affected', 'break', 'breaks', 'failing',
+    'implemented', 'implement',
+    // Code-specific noise (avoid filtering common symbol names like get/set/add/build/find/list)
+    'code', 'file', 'files', 'function', 'method', 'class', 'type',
+    'fix', 'bug', 'called',
+]);
+/**
+ * Generate stem variants of a search term by removing common English suffixes.
+ * Used for FTS query expansion so "caching" also finds "cache", "eviction" finds "evict", etc.
+ * Stems are used as PREFIX matches in FTS, so they don't need to be perfect English words.
+ */
+function getStemVariants(term) {
+    const variants = new Set();
+    const t = term.toLowerCase();
+    // -ing: caching→cach/cache, handling→handl/handle, running→run
+    if (t.endsWith('ing') && t.length > 5) {
+        const base = t.slice(0, -3);
+        variants.add(base);
+        variants.add(base + 'e');
+        if (base.length >= 2 && base[base.length - 1] === base[base.length - 2]) {
+            variants.add(base.slice(0, -1));
+        }
+    }
+    // -tion/-sion: eviction→evict, expression→express
+    if ((t.endsWith('tion') || t.endsWith('sion')) && t.length > 5) {
+        variants.add(t.slice(0, -3));
+    }
+    // -ment: management→manage
+    if (t.endsWith('ment') && t.length > 6) {
+        variants.add(t.slice(0, -4));
+    }
+    // -ies: entries→entry
+    if (t.endsWith('ies') && t.length > 4) {
+        variants.add(t.slice(0, -3) + 'y');
+    }
+    // -es: processes→process, classes→class
+    else if (t.endsWith('es') && t.length > 4) {
+        variants.add(t.slice(0, -2));
+    }
+    // -s: errors→error (skip -ss endings like "class")
+    else if (t.endsWith('s') && !t.endsWith('ss') && t.length > 4) {
+        variants.add(t.slice(0, -1));
+    }
+    // -ed: handled→handle, propagated→propagate, carried→carry
+    if (t.endsWith('ed') && !t.endsWith('eed') && t.length > 4) {
+        variants.add(t.slice(0, -1));
+        variants.add(t.slice(0, -2));
+        if (t.endsWith('ied') && t.length > 5) {
+            variants.add(t.slice(0, -3) + 'y');
+        }
+    }
+    // -er: builder→build/builde, handler→handl/handle, getter→get
+    if (t.endsWith('er') && t.length > 4) {
+        const base = t.slice(0, -2);
+        variants.add(base);
+        variants.add(base + 'e');
+        if (base.length >= 2 && base[base.length - 1] === base[base.length - 2]) {
+            variants.add(base.slice(0, -1));
+        }
+    }
+    return [...variants].filter(v => v.length >= 3 && v !== t);
+}
+/**
+ * Extract meaningful search terms from a natural language query.
+ * Splits camelCase, PascalCase, snake_case, SCREAMING_SNAKE, and dot.notation
+ * into individual tokens before filtering.
+ *
+ * Preserves original compound identifiers (e.g., "scrapeLoop") alongside
+ * their split parts so that FTS can match both the full symbol name and
+ * individual words within it.
+ *
+ * Also generates stem variants (e.g., "caching"→"cache", "eviction"→"evict")
+ * so FTS prefix matching can find related code symbols.
+ */
+function extractSearchTerms(query, options) {
+    const includeStems = options?.stems !== false;
+    const tokens = new Set();
+    // CJK detection: extract Chinese/Japanese/Korean character sequences
+    // before the ASCII split destroys them. FTS5 unicode61 treats CJK
+    // as monolithic tokens, so CJK search terms fall through to the LIKE
+    // path. Bigrams + trigrams give useful substring matching for Chinese
+    // text in docstrings and comments.
+    const cjkPattern = /[\u4e00-\u9fff\u3400-\u4dbf\uf900-\ufaff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]+/g;
+    let cjkMatch;
+    const cjkTerms = [];
+    while ((cjkMatch = cjkPattern.exec(query)) !== null) {
+        const text = cjkMatch[0];
+        // Keep the full CJK sequence as a token (e.g. "认证中间件")
+        if (text.length >= 2) {
+            cjkTerms.push(text);
+        }
+        // Generate bigrams for substring matching (e.g. "认证", "证中", "中间", "间件")
+        for (let i = 0; i < text.length - 1; i++) {
+            cjkTerms.push(text.slice(i, i + 2));
+        }
+        // Generate trigrams for more precise matching (e.g. "认证中", "证中间", "中间件")
+        for (let i = 0; i < text.length - 2; i++) {
+            cjkTerms.push(text.slice(i, i + 3));
+        }
+    }
+    // Cap CJK terms at 8 to prevent query explosion in buildContext
+    // (which calls searchNodes for each term individually)
+    const uniqueCjk = [...new Set(cjkTerms)];
+    // Prefer longer terms (more specific) over shorter ones
+    uniqueCjk.sort((a, b) => b.length - a.length);
+    for (const term of uniqueCjk.slice(0, 8)) {
+        tokens.add(term);
+    }
+    // Remove CJK from query before ASCII processing to avoid interference
+    const asciiQuery = query.replace(cjkPattern, ' ');
+    // First, extract and preserve compound identifiers before splitting
+    // CamelCase: scrapeLoop, UserService, getCallGraph
+    const compoundPattern = /\b([a-zA-Z][a-zA-Z0-9]*(?:[A-Z][a-z]+)+|[A-Z][a-z]+(?:[A-Z][a-z]*)+)\b/g;
+    let match;
+    while ((match = compoundPattern.exec(asciiQuery)) !== null) {
+        if (match[1] && match[1].length >= 3) {
+            tokens.add(match[1].toLowerCase()); // preserve full compound: "scrapeloop"
+        }
+    }
+    // snake_case: scrape_loop, user_service
+    const snakePattern = /\b([a-zA-Z][a-zA-Z0-9]*(?:_[a-zA-Z0-9]+)+)\b/g;
+    while ((match = snakePattern.exec(asciiQuery)) !== null) {
+        if (match[1] && match[1].length >= 3) {
+            tokens.add(match[1].toLowerCase());
+        }
+    }
+    // Split camelCase / PascalCase: "getUserName" → "get User Name"
+    const camelSplit = asciiQuery
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');
+    // Replace underscores and dots with spaces (snake_case, dot.notation)
+    const normalised = camelSplit.replace(/[_.]+/g, ' ');
+    // Split on any non-alphanumeric character (CJK already extracted above)
+    const words = normalised.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+    for (const word of words) {
+        const lower = word.toLowerCase();
+        if (lower.length < 3)
+            continue;
+        if (exports.STOP_WORDS.has(lower))
+            continue;
+        tokens.add(lower);
+    }
+    // Generate stem variants for broader FTS matching.
+    // "caching" → "cache" finds CacheBuilder; "eviction" → "evict" finds evictEntries.
+    // Also enables co-occurrence dampening by increasing term count above 1.
+    // Stems are skipped when scoring path relevance (stems inflate path scores).
+    if (includeStems) {
+        const stems = new Set();
+        for (const token of tokens) {
+            for (const variant of getStemVariants(token)) {
+                if (!tokens.has(variant) && !exports.STOP_WORDS.has(variant)) {
+                    stems.add(variant);
+                }
+            }
+        }
+        for (const stem of stems) {
+            tokens.add(stem);
+        }
+    }
+    return [...tokens];
+}
+/**
+ * Score path relevance to a query
+ * Higher score = more relevant path
+ */
+function scorePathRelevance(filePath, query) {
+    // Use base terms only — stem variants inflate path scores by generating
+    // many near-duplicate terms that all match the same path segments.
+    const terms = extractSearchTerms(query, { stems: false });
+    if (terms.length === 0)
+        return 0;
+    const pathLower = filePath.toLowerCase();
+    const fileName = path.basename(filePath).toLowerCase();
+    const dirName = path.dirname(filePath).toLowerCase();
+    let score = 0;
+    for (const term of terms) {
+        // Exact filename match (strongest)
+        if (fileName.includes(term))
+            score += 10;
+        // Directory match
+        if (dirName.includes(term))
+            score += 5;
+        // General path match
+        else if (pathLower.includes(term))
+            score += 3;
+    }
+    // Deprioritize test files unless the query is explicitly about tests
+    const queryLower = query.toLowerCase();
+    const isTestQuery = queryLower.includes('test') || queryLower.includes('spec');
+    if (!isTestQuery && isTestFile(filePath)) {
+        score -= 15;
+    }
+    return score;
+}
+/**
+ * Check if a file path looks like a test file
+ */
+function isTestFile(filePath) {
+    const lower = filePath.toLowerCase();
+    const fileName = path.basename(filePath); // original case — needed for camelCase boundaries
+    const lowerName = fileName.toLowerCase();
+    // --- Filename patterns ---
+    if (lowerName.startsWith('test_') || // python: test_foo.py
+        lowerName.startsWith('test.') ||
+        // separator-delimited: foo_test.go, foo.test.ts, foo-spec.rb, bar_spec.py
+        /[._-](test|tests|spec|specs)\.[a-z0-9]+$/.test(lowerName) ||
+        // CamelCase suffix (Java/Kotlin/Swift/C#/Scala): FooTest.kt, BarTests.swift,
+        // BazSpec.scala, QuxTestCase.java. Capital-led so "latest.kt"/"manifest.kt"
+        // (lowercase "test") are NOT matched.
+        /(?:Test|Tests|TestCase|Tester|Spec|Specs)\.[A-Za-z0-9]+$/.test(fileName)) {
+        return true;
+    }
+    // --- Directory patterns ---
+    if (lower.includes('/tests/') || lower.includes('/test/') ||
+        lower.includes('/__tests__/') || lower.includes('/spec/') ||
+        lower.includes('/specs/') || lower.includes('/testlib/') ||
+        lower.includes('/testing/') ||
+        lower.startsWith('test/') || lower.startsWith('tests/') ||
+        lower.startsWith('spec/') || lower.startsWith('specs/') ||
+        // CamelCase test source-set dirs (Kotlin Multiplatform / Gradle / Xcode):
+        // jvmTest/, commonTest/, androidTest/, iosTest/, integrationTest/. Capital-led
+        // so "latest/" / "manifest/" are not matched.
+        /(?:^|\/)[A-Za-z0-9]*(?:Test|Tests|Spec)\//.test(filePath)) {
+        return true;
+    }
+    // Non-production directories: examples, samples, benchmarks, fixtures, demos.
+    // Check both mid-path (/integration/) and start-of-path (integration/) since
+    // file paths may be stored as relative paths without a leading slash.
+    return matchesNonProductionDir(lower);
+}
+/**
+ * Check if a path is in a non-production directory (integration, sample, example, etc.)
+ * Handles both absolute paths (/foo/integration/bar) and relative paths (integration/bar).
+ */
+function matchesNonProductionDir(lowerPath) {
+    const dirs = [
+        'integration', 'sample', 'samples', 'example', 'examples',
+        'fixture', 'fixtures', 'benchmark', 'benchmarks', 'demo', 'demos',
+    ];
+    for (const dir of dirs) {
+        if (lowerPath.includes('/' + dir + '/') || lowerPath.startsWith(dir + '/')) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Bonus when a node's name matches the search query.
+ * Exact matches get the largest boost; prefix matches get smaller boosts.
+ * Multi-word queries also check individual term matches against the name.
+ */
+function nameMatchBonus(nodeName, query) {
+    const nameLower = nodeName.toLowerCase();
+    // Split query into word-level terms (handles "CacheBuilder build" → ["cache","builder","build"])
+    const rawTerms = query
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .split(/[\s_.\-]+/)
+        .map(t => t.toLowerCase())
+        .filter(t => t.length >= 2);
+    // Also keep original space-separated tokens for exact-term matching
+    const queryTokens = query.split(/\s+/).map(t => t.toLowerCase()).filter(t => t.length >= 2);
+    // Full query as a single token (for compound identifiers like "CacheBuilder")
+    const queryLower = query.replace(/[\s]+/g, '').toLowerCase();
+    // Exact match: query exactly equals the node name
+    if (nameLower === queryLower)
+        return 80;
+    // Exact match on a query token: "CacheBuilder build" and node name is "build"
+    if (queryTokens.length > 1 && queryTokens.includes(nameLower))
+        return 60;
+    // Name starts with query — scale by length ratio so "Pod"→"Pod" (exact, handled above)
+    // scores much higher than "Pod"→"PodGCControllerOptions" (ratio 0.125).
+    if (nameLower.startsWith(queryLower)) {
+        const ratio = queryLower.length / nameLower.length;
+        return Math.round(10 + 30 * ratio);
+    }
+    // All camelCase-split terms appear in the name
+    if (rawTerms.length > 1) {
+        const allMatch = rawTerms.every(t => nameLower.includes(t));
+        if (allMatch)
+            return 15;
+    }
+    // Name contains the full query as substring
+    if (nameLower.includes(queryLower))
+        return 10;
+    return 0;
+}
+/**
+ * Kind-based bonus for search ranking
+ * Functions and classes are typically more relevant than variables/imports
+ */
+function kindBonus(kind) {
+    const bonuses = {
+        function: 10,
+        method: 10,
+        class: 8,
+        interface: 9,
+        type_alias: 6,
+        struct: 6,
+        trait: 9,
+        enum: 5,
+        component: 8,
+        route: 9,
+        module: 4,
+        property: 3,
+        field: 3,
+        variable: 2,
+        constant: 3,
+        import: 1,
+        export: 1,
+        parameter: 0,
+        namespace: 4,
+        file: 0,
+        protocol: 9,
+        enum_member: 3,
+    };
+    return bonuses[kind] ?? 0;
+}
+//# sourceMappingURL=query-utils.js.map

package/dist/sync/git-hooks.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Git Sync Hooks
+ *
+ * When the live file watcher is disabled (e.g. on WSL2 `/mnt/*` drives,
+ * see watch-policy.ts), the CodeGraph index would otherwise go stale until
+ * the user runs `codegraph sync` by hand. As an opt-in alternative, we can
+ * install git hooks that refresh the index after the operations that change
+ * files on disk: commit, merge (covers `git pull`), and checkout.
+ *
+ * The hooks run `codegraph sync` in the background so they never block git,
+ * and are guarded by `command -v codegraph` so they no-op cleanly when the
+ * CLI isn't on PATH. Our snippet is delimited by marker comments so install
+ * is idempotent and removal preserves any user-authored hook content.
+ */
+export type GitHookName = 'post-commit' | 'post-merge' | 'post-checkout'
+/** Hooks installed by default: commit, merge (git pull), and checkout. */
+export declare const DEFAULT_SYNC_HOOKS: GitHookName[]
+export interface GitHookResult {
+  /** Hook names that were created or updated. */
+  installed: GitHookName[]
+  /** Resolved hooks directory, or null when not a git repo. */
+  hooksDir: string | null
+  /** Reason nothing happened (e.g. not a git repository). */
+  skipped?: string
+}
+/**
+ * Whether `projectRoot` is inside a git working tree. Returns false if git
+ * isn't installed or the path isn't a repo.
+ */
+export declare function isGitRepo(projectRoot: string): boolean
+/**
+ * Install (or update) the CodeGraph sync hooks in a git repository.
+ * Idempotent: re-running replaces our marker block rather than duplicating
+ * it, and any user-authored hook content is preserved.
+ */
+export declare function installGitSyncHook(
+  projectRoot: string,
+  hooks?: GitHookName[],
+): GitHookResult
+/**
+ * Remove the CodeGraph sync hooks. Strips only our marker block; deletes the
+ * hook file entirely when nothing but a shebang remains, otherwise rewrites
+ * the user's content untouched.
+ */
+export declare function removeGitSyncHook(
+  projectRoot: string,
+  hooks?: GitHookName[],
+): GitHookResult
+/** Whether any CodeGraph sync hook is currently installed. */
+export declare function isSyncHookInstalled(
+  projectRoot: string,
+  hooks?: GitHookName[],
+): boolean
+//# sourceMappingURL=git-hooks.d.ts.map