@egentica/codemap 0.1.5

package/dist/assist/PatternAggregator.js

@@ -0,0 +1,311 @@
+"use strict";
+/**
+ * PatternAggregator - Analyzes experience data to extract scoring patterns.
+ *
+ * Reads from ExperienceStore and provides:
+ * - Query pattern matching (which queries led to which files)
+ * - Usage metadata matching (curated usage phrases)
+ * - Anti-result penalties (learn from mistakes)
+ * - File experience metrics (success rate, recency, heat)
+ * - Symbol experience metrics (edit history, keywords)
+ *
+ * This is the intelligence layer that powers AssistMap's experience scoring.
+ *
+ * @example
+ * ```typescript
+ * const aggregator = new PatternAggregator(experienceStore);
+ *
+ * // Get query pattern matches
+ * const matches = await aggregator.getQueryPatternMatches('file.ts', 'make cards draggable');
+ * // → Returns matching queries + confidence score
+ *
+ * // Get usage metadata matches
+ * const usageMatches = await aggregator.getUsageMatches('make cards draggable');
+ * // → Returns files with matching usage phrases
+ *
+ * // Get anti-result penalty
+ * const penalty = await aggregator.getAntiResultPenalty('file.ts', 'drag drop');
+ * // → Returns negative score if this file was previously rejected
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternAggregator = void 0;
+class PatternAggregator {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    // ── Query Pattern Matching ─────────────────────────────────────────────────
+    /**
+     * Get query pattern matches for a file.
+     *
+     * Finds successful queries from journey history that led to this file.
+     *
+     * @param filePath - Target file path
+     * @param currentQuery - Current query to compare against
+     * @returns Query pattern match result
+     */
+    async getQueryPatternMatches(filePath, currentQuery) {
+        // Get journeys that ended with this file
+        const journeys = await this.store.getJourneysForFile(filePath);
+        if (journeys.length === 0) {
+            return {
+                file: filePath,
+                matchingQueries: [],
+                score: 0
+            };
+        }
+        // Extract queries that led to this file
+        const matchingQueries = [];
+        const currentKeywords = this.extractKeywords(currentQuery);
+        for (const journey of journeys) {
+            for (const step of journey.searchPath) {
+                // Check if this step's query is similar to current query
+                const stepKeywords = this.extractKeywords(step.query);
+                const overlap = this.calculateKeywordOverlap(currentKeywords, stepKeywords);
+                if (overlap >= 0.5) { // 50% keyword overlap threshold
+                    matchingQueries.push({
+                        query: step.query,
+                        timestamp: step.timestamp
+                    });
+                }
+            }
+        }
+        // Calculate confidence score
+        const score = Math.min(matchingQueries.length / 5, 1.0); // Cap at 5 matches
+        return {
+            file: filePath,
+            matchingQueries,
+            score
+        };
+    }
+    // ── Usage Metadata Matching ────────────────────────────────────────────────
+    /**
+     * Get usage metadata matches for a query.
+     *
+     * Finds files with usage phrases matching the query.
+     *
+     * @param query - Search query
+     * @returns Array of usage matches
+     */
+    async getUsageMatches(query) {
+        const allMetadata = await this.store.getAllUsageMetadata();
+        const matches = [];
+        const queryKeywords = this.extractKeywords(query);
+        for (const metadata of allMetadata) {
+            const matchingUsages = [];
+            for (const usage of metadata.usages) {
+                const usageKeywords = this.extractKeywords(usage);
+                const overlap = this.calculateKeywordOverlap(queryKeywords, usageKeywords);
+                if (overlap >= 0.4) { // 40% threshold for usage matches
+                    matchingUsages.push(usage);
+                }
+            }
+            if (matchingUsages.length > 0) {
+                matches.push({
+                    file: metadata.target,
+                    matchingUsages,
+                    score: Math.min(matchingUsages.length / 3, 1.0) // Cap at 3 matches
+                });
+            }
+        }
+        return matches;
+    }
+    // ── Anti-Result Penalties ──────────────────────────────────────────────────
+    /**
+     * Get anti-result penalty for a file.
+     *
+     * Returns negative score if this file was previously shown but rejected
+     * or abandoned for similar queries.
+     *
+     * @param filePath - File path
+     * @param currentQuery - Current query
+     * @returns Anti-result penalty
+     */
+    async getAntiResultPenalty(filePath, currentQuery) {
+        const antiResults = await this.store.getAntiResults(filePath);
+        if (antiResults.length === 0) {
+            return {
+                file: filePath,
+                penalty: 0,
+                reason: 'no_anti_results'
+            };
+        }
+        let penalty = 0;
+        const queryKeywords = this.extractKeywords(currentQuery);
+        for (const anti of antiResults) {
+            const antiKeywords = this.extractKeywords(anti.query);
+            const overlap = this.calculateKeywordOverlap(queryKeywords, antiKeywords);
+            if (overlap >= 0.5) { // 50% overlap with failed query
+                const basePenalty = anti.reason === 'read_but_abandoned' ? -3 : -1;
+                penalty += basePenalty;
+            }
+        }
+        // Cap penalty at -10
+        penalty = Math.max(penalty, -10);
+        return {
+            file: filePath,
+            penalty,
+            reason: penalty < 0 ? 'similar_to_failed_queries' : 'no_relevant_anti_results'
+        };
+    }
+    // ── File Experience Metrics ────────────────────────────────────────────────
+    /**
+     * Get experience metrics for a file.
+     *
+     * @param filePath - File path
+     * @returns File experience metrics
+     */
+    async getFileMetrics(filePath) {
+        const events = await this.getEventsForFile(filePath);
+        if (events.length === 0) {
+            return {
+                successRate: 0,
+                totalOps: 0,
+                successfulOps: 0,
+                heatScore: 0
+            };
+        }
+        const successfulOps = events.filter(e => e.outcome === 'success').length;
+        const successRate = successfulOps / events.length;
+        // Find most recent event
+        const sortedEvents = events.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        const lastAccessed = sortedEvents[0]?.timestamp;
+        // Calculate days since last access
+        const daysSinceAccess = lastAccessed
+            ? (Date.now() - new Date(lastAccessed).getTime()) / (1000 * 60 * 60 * 24)
+            : undefined;
+        // Calculate heat score (decays over time)
+        const heatScore = this.calculateHeatScore(events);
+        return {
+            successRate,
+            totalOps: events.length,
+            successfulOps,
+            lastAccessed,
+            daysSinceAccess,
+            heatScore
+        };
+    }
+    // ── Symbol Experience Metrics ──────────────────────────────────────────────
+    /**
+     * Get symbol experience metrics for a file.
+     *
+     * @param filePath - File path
+     * @returns Array of symbol metrics
+     */
+    async getSymbolMetrics(filePath) {
+        const events = await this.getEventsForFile(filePath);
+        const symbolMap = new Map();
+        for (const event of events) {
+            if (event.symbolMetadata) {
+                const { symbolRef } = event.symbolMetadata;
+                const existing = symbolMap.get(symbolRef) || { editCount: 0, successes: 0 };
+                existing.editCount++;
+                if (event.outcome === 'success') {
+                    existing.successes++;
+                }
+                symbolMap.set(symbolRef, existing);
+            }
+        }
+        const metrics = [];
+        for (const [symbolRef, stats] of symbolMap.entries()) {
+            // Extract domain keywords from symbolRef
+            // e.g., "src/renderer/components/TaskCard.vue$handleDragStart"
+            const domainKeywords = this.extractDomainKeywords(symbolRef);
+            metrics.push({
+                symbolRef,
+                editCount: stats.editCount,
+                successRate: stats.successes / stats.editCount,
+                domainKeywords
+            });
+        }
+        return metrics;
+    }
+    // ── Utilities ──────────────────────────────────────────────────────────────
+    /**
+     * Get all events for a specific file.
+     *
+     * @param filePath - File path
+     * @returns Array of events
+     */
+    async getEventsForFile(filePath) {
+        // Get current session events
+        const events = await this.store.getCurrentSessionEvents();
+        // Filter to this file
+        return events.filter(e => e.target === filePath);
+    }
+    /**
+     * Extract keywords from a query string.
+     *
+     * @param text - Query text
+     * @returns Array of keywords
+     */
+    extractKeywords(text) {
+        // Convert to lowercase, split on non-alphanumeric
+        const words = text.toLowerCase().split(/[^a-z0-9]+/);
+        // Filter out stop words and short words
+        const stopWords = new Set(['a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'to', 'of', 'in', 'on', 'at']);
+        return words
+            .filter(w => w.length > 2 && !stopWords.has(w))
+            .filter((w, i, arr) => arr.indexOf(w) === i); // Deduplicate
+    }
+    /**
+     * Calculate keyword overlap between two keyword sets.
+     *
+     * @param keywords1 - First set
+     * @param keywords2 - Second set
+     * @returns Overlap ratio (0-1)
+     */
+    calculateKeywordOverlap(keywords1, keywords2) {
+        if (keywords1.length === 0 || keywords2.length === 0) {
+            return 0;
+        }
+        const set1 = new Set(keywords1);
+        const set2 = new Set(keywords2);
+        let overlap = 0;
+        for (const keyword of set1) {
+            if (set2.has(keyword)) {
+                overlap++;
+            }
+        }
+        return overlap / Math.max(keywords1.length, keywords2.length);
+    }
+    /**
+     * Calculate heat score based on recent activity.
+     *
+     * @param events - Events for a file
+     * @returns Heat score (0-1)
+     */
+    calculateHeatScore(events) {
+        if (events.length === 0)
+            return 0;
+        const now = Date.now();
+        const sevenDaysAgo = now - (7 * 24 * 60 * 60 * 1000);
+        // Count events in last 7 days
+        const recentEvents = events.filter((e) => new Date(e.timestamp).getTime() > sevenDaysAgo);
+        // Heat score: 0.1 per recent event, capped at 1.0
+        return Math.min(recentEvents.length * 0.1, 1.0);
+    }
+    /**
+     * Extract domain keywords from a symbol reference.
+     *
+     * @param symbolRef - Symbol reference (e.g., "src/renderer/components/TaskCard.vue$handleDragStart")
+     * @returns Array of domain keywords
+     */
+    extractDomainKeywords(symbolRef) {
+        // Split on $ to separate path from symbol name
+        const [path, symbolName] = symbolRef.split('$');
+        // Split path on slashes and dots to extract meaningful parts
+        const parts = [...path.split('/'), ...(symbolName ? [symbolName] : [])];
+        // Extract camelCase/PascalCase words
+        const keywords = [];
+        for (const part of parts) {
+            // Split camelCase: handleDragStart → [handle, drag, start]
+            const camelWords = part.replace(/([A-Z])/g, ' $1').trim().split(/\s+/);
+            keywords.push(...camelWords.map(w => w.toLowerCase()));
+        }
+        return keywords.filter(k => k.length > 2);
+    }
+}
+exports.PatternAggregator = PatternAggregator;
+//# sourceMappingURL=PatternAggregator.js.map

package/dist/assist/PatternAggregator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PatternAggregator.js","sourceRoot":"","sources":["../../src/assist/PatternAggregator.ts"],"names":[],"mappings":"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"}

package/dist/assist/RelevanceScorer.d.ts

@@ -0,0 +1,104 @@
+/**
+ * RelevanceScorer — Search-engine-quality file ranking.
+ *
+ * Deep-dives every file to score relevance based on multiple factors:
+ * - Domain annotations (@codemap.domain.*)
+ * - Usage metadata (@codemap.meta.usage, keywords)
+ * - Core annotations (policy, systempolicy, note, warning)
+ * - Symbol names (functions, classes, exports)
+ * - File path keywords
+ * - Word matching with frequency weighting
+ *
+ * Best-ranked files bubble to the top like a real search engine.
+ */
+import type { FileEntry } from '../types';
+/**
+ * Scored file result.
+ */
+export interface ScoredFile {
+    file: FileEntry;
+    score: number;
+    breakdown: ScoreBreakdown;
+}
+/**
+ * Score breakdown for debugging.
+ */
+export interface ScoreBreakdown {
+    domainScore: number;
+    usageScore: number;
+    policyScore: number;
+    symbolScore: number;
+    pathScore: number;
+    wordMatchScore: number;
+    totalMatches: number;
+}
+/**
+ * Scoring weights (tunable).
+ */
+export interface ScoringWeights {
+    domain: number;
+    usage: number;
+    policy: number;
+    symbol: number;
+    path: number;
+    wordMatch: number;
+}
+export declare class RelevanceScorer {
+    private weights;
+    private queryTokens;
+    constructor(weights?: ScoringWeights);
+    /**
+     * Score all files for a given goal/query.
+     *
+     * @param files - All files to score
+     * @param goal - User's goal/query
+     * @param topN - Number of top results to return
+     * @returns Top N scored files
+     */
+    scoreFiles(files: FileEntry[], goal: string, topN?: number): ScoredFile[];
+    /**
+     * Score a single file.
+     */
+    private scoreFile;
+    /**
+     * Score domain annotations.
+     * Domain is the STRONGEST signal — explicit project vocabulary.
+     */
+    private scoreDomains;
+    /**
+     * Score usage metadata.
+     * Usage is explicit — tells us WHEN to use this file.
+     */
+    private scoreUsage;
+    /**
+     * Score policy annotations.
+     * Policies contain architectural keywords and constraints.
+     */
+    private scorePolicies;
+    /**
+     * Score symbol names.
+     * Function/class names are strong intent signals.
+     */
+    private scoreSymbols;
+    /**
+     * Score file path keywords.
+     * Path structure reveals intent (e.g., src/auth/login.ts).
+     */
+    private scorePath;
+    /**
+     * Generic word matching across all text.
+     * Weakest signal but catches everything else.
+     */
+    private scoreWordMatch;
+    /**
+     * Count how many query tokens appear in target tokens.
+     * Uses TF-like weighting — more occurrences = higher score.
+     */
+    private countMatches;
+    /**
+     * Tokenize text into words.
+     * Handles camelCase, PascalCase, snake_case, kebab-case.
+     */
+    private tokenize;
+}
+//# sourceMappingURL=RelevanceScorer.d.ts.map

package/dist/assist/RelevanceScorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RelevanceScorer.d.ts","sourceRoot":"","sources":["../../src/assist/RelevanceScorer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,cAAc,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAWD,qBAAa,eAAe;IAE1B,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,WAAW,CAAW;gBAElB,OAAO,GAAE,cAAgC;IAKrD;;;;;;;OAOG;IACH,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAW,GAAG,UAAU,EAAE;IAc7E;;OAEG;IACH,OAAO,CAAC,SAAS;IAyCjB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAyBpB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAuBlB;;;OAGG;IACH,OAAO,CAAC,aAAa;IAmBrB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAyBpB;;;OAGG;IACH,OAAO,CAAC,SAAS;IAQjB;;;OAGG;IACH,OAAO,CAAC,cAAc;IA0BtB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAwBpB;;;OAGG;IACH,OAAO,CAAC,QAAQ;CAQjB"}

package/dist/assist/RelevanceScorer.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * RelevanceScorer — Search-engine-quality file ranking.
+ *
+ * Deep-dives every file to score relevance based on multiple factors:
+ * - Domain annotations (@codemap.domain.*)
+ * - Usage metadata (@codemap.meta.usage, keywords)
+ * - Core annotations (policy, systempolicy, note, warning)
+ * - Symbol names (functions, classes, exports)
+ * - File path keywords
+ * - Word matching with frequency weighting
+ *
+ * Best-ranked files bubble to the top like a real search engine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelevanceScorer = void 0;
+const DEFAULT_WEIGHTS = {
+    domain: 10.0, // Highest weight — domain is THE relevance signal
+    usage: 8.0, // Usage metadata is explicit intent
+    policy: 5.0, // Policies contain architectural keywords
+    symbol: 4.0, // Symbol names are strong signals
+    path: 3.0, // Path keywords are moderate signals
+    wordMatch: 1.0, // Base word matching
+};
+class RelevanceScorer {
+    weights;
+    queryTokens;
+    constructor(weights = DEFAULT_WEIGHTS) {
+        this.weights = weights;
+        this.queryTokens = [];
+    }
+    /**
+     * Score all files for a given goal/query.
+     *
+     * @param files - All files to score
+     * @param goal - User's goal/query
+     * @param topN - Number of top results to return
+     * @returns Top N scored files
+     */
+    scoreFiles(files, goal, topN = 10) {
+        // Tokenize query
+        this.queryTokens = this.tokenize(goal);
+        // Score all files
+        const scored = files.map(file => this.scoreFile(file));
+        // Sort by score descending
+        scored.sort((a, b) => b.score - a.score);
+        // Return top N
+        return scored.slice(0, topN);
+    }
+    /**
+     * Score a single file.
+     */
+    scoreFile(file) {
+        const breakdown = {
+            domainScore: 0,
+            usageScore: 0,
+            policyScore: 0,
+            symbolScore: 0,
+            pathScore: 0,
+            wordMatchScore: 0,
+            totalMatches: 0,
+        };
+        // 1. Domain annotations (@codemap.domain.*)
+        breakdown.domainScore = this.scoreDomains(file);
+        // 2. Usage metadata (@codemap.meta.usage, keywords)
+        breakdown.usageScore = this.scoreUsage(file);
+        // 3. Policy annotations
+        breakdown.policyScore = this.scorePolicies(file);
+        // 4. Symbol names
+        breakdown.symbolScore = this.scoreSymbols(file);
+        // 5. File path keywords
+        breakdown.pathScore = this.scorePath(file);
+        // 6. Generic word matching
+        breakdown.wordMatchScore = this.scoreWordMatch(file);
+        // Calculate total score
+        const score = breakdown.domainScore * this.weights.domain +
+            breakdown.usageScore * this.weights.usage +
+            breakdown.policyScore * this.weights.policy +
+            breakdown.symbolScore * this.weights.symbol +
+            breakdown.pathScore * this.weights.path +
+            breakdown.wordMatchScore * this.weights.wordMatch;
+        return { file, score, breakdown };
+    }
+    /**
+     * Score domain annotations.
+     * Domain is the STRONGEST signal — explicit project vocabulary.
+     */
+    scoreDomains(file) {
+        if (!file.categorizedAnnotations)
+            return 0;
+        const domainAnnotations = file.categorizedAnnotations.filter(ann => ann.category === 'domain');
+        if (domainAnnotations.length === 0)
+            return 0;
+        let score = 0;
+        for (const ann of domainAnnotations) {
+            // Check if annotation value matches query tokens
+            const annTokens = this.tokenize(ann.value);
+            const matches = this.countMatches(this.queryTokens, annTokens);
+            score += matches;
+            // Bonus for path matches (e.g., domain.medical.diagnosis)
+            const pathTokens = this.tokenize(ann.path);
+            const pathMatches = this.countMatches(this.queryTokens, pathTokens);
+            score += pathMatches * 0.5;
+        }
+        return score;
+    }
+    /**
+     * Score usage metadata.
+     * Usage is explicit — tells us WHEN to use this file.
+     */
+    scoreUsage(file) {
+        if (!file.categorizedAnnotations)
+            return 0;
+        const usageAnnotations = file.categorizedAnnotations.filter(ann => ann.category === 'meta' && (ann.path.includes('usage') ||
+            ann.path.includes('keyword') ||
+            ann.path.includes('tag')));
+        if (usageAnnotations.length === 0)
+            return 0;
+        let score = 0;
+        for (const ann of usageAnnotations) {
+            const annTokens = this.tokenize(ann.value);
+            const matches = this.countMatches(this.queryTokens, annTokens);
+            score += matches * 1.5; // Boost usage matches
+        }
+        return score;
+    }
+    /**
+     * Score policy annotations.
+     * Policies contain architectural keywords and constraints.
+     */
+    scorePolicies(file) {
+        if (!file.annotations)
+            return 0;
+        const policyAnnotations = file.annotations.filter(ann => ann.type === 'policy' || ann.type === 'systempolicy');
+        if (policyAnnotations.length === 0)
+            return 0;
+        let score = 0;
+        for (const ann of policyAnnotations) {
+            const annTokens = this.tokenize(ann.message);
+            const matches = this.countMatches(this.queryTokens, annTokens);
+            score += matches * 0.8; // Policy matches are good but not strongest
+        }
+        return score;
+    }
+    /**
+     * Score symbol names.
+     * Function/class names are strong intent signals.
+     */
+    scoreSymbols(file) {
+        if (!file.symbols || file.symbols.length === 0)
+            return 0;
+        let score = 0;
+        for (const symbol of file.symbols) {
+            // Check symbol name
+            const nameTokens = this.tokenize(symbol.name);
+            const nameMatches = this.countMatches(this.queryTokens, nameTokens);
+            score += nameMatches;
+            // Bonus for exported symbols (public API)
+            if (symbol.exported) {
+                score += nameMatches * 0.3;
+            }
+            // Check symbol kind matches
+            const kindMatch = this.queryTokens.some(t => symbol.kind.toLowerCase().includes(t.toLowerCase()));
+            if (kindMatch)
+                score += 0.5;
+        }
+        return score;
+    }
+    /**
+     * Score file path keywords.
+     * Path structure reveals intent (e.g., src/auth/login.ts).
+     */
+    scorePath(file) {
+        const pathParts = file.relativePath.split(/[\/\\]/);
+        const pathTokens = pathParts.flatMap(part => this.tokenize(part));
+        const matches = this.countMatches(this.queryTokens, pathTokens);
+        return matches;
+    }
+    /**
+     * Generic word matching across all text.
+     * Weakest signal but catches everything else.
+     */
+    scoreWordMatch(file) {
+        // Collect all text from file
+        const allText = [];
+        // Add relative path
+        allText.push(file.relativePath);
+        // Add all annotation text
+        if (file.annotations) {
+            allText.push(...file.annotations.map(a => a.message));
+        }
+        if (file.categorizedAnnotations) {
+            allText.push(...file.categorizedAnnotations.map(a => `${a.path} ${a.value}`));
+        }
+        // Add all symbol names
+        if (file.symbols) {
+            allText.push(...file.symbols.map(s => s.name));
+        }
+        // Tokenize and count matches
+        const allTokens = allText.flatMap(text => this.tokenize(text));
+        return this.countMatches(this.queryTokens, allTokens);
+    }
+    /**
+     * Count how many query tokens appear in target tokens.
+     * Uses TF-like weighting — more occurrences = higher score.
+     */
+    countMatches(queryTokens, targetTokens) {
+        const targetSet = new Map();
+        // Count frequency of each token in target
+        for (const token of targetTokens) {
+            const lower = token.toLowerCase();
+            targetSet.set(lower, (targetSet.get(lower) || 0) + 1);
+        }
+        // Sum matches with frequency weighting
+        let score = 0;
+        for (const queryToken of queryTokens) {
+            const lower = queryToken.toLowerCase();
+            const freq = targetSet.get(lower) || 0;
+            // Score: 1 for first occurrence, +0.2 for each additional
+            if (freq > 0) {
+                score += 1 + (freq - 1) * 0.2;
+            }
+        }
+        return score;
+    }
+    /**
+     * Tokenize text into words.
+     * Handles camelCase, PascalCase, snake_case, kebab-case.
+     */
+    tokenize(text) {
+        return text
+            .replace(/([a-z])([A-Z])/g, '$1 $2') // camelCase → camel Case
+            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2') // XMLParser → XML Parser
+            .split(/[\s_\-\.\/\\]+/) // Split on whitespace, _, -, ., /, \
+            .filter(t => t.length > 2) // Filter out short tokens
+            .map(t => t.toLowerCase());
+    }
+}
+exports.RelevanceScorer = RelevanceScorer;
+//# sourceMappingURL=RelevanceScorer.js.map