@dreb/coding-agent 1.16.0

package/dist/core/search/metrics/import-graph.js

@@ -0,0 +1,115 @@
+/**
+ * Import graph proximity metric.
+ *
+ * Files that import or are imported by high-scoring files get a boost.
+ * Uses a simple 1-hop propagation from seed scores.
+ */
+/** Fraction of seed score propagated to neighbors. */
+const PROPAGATION_FACTOR = 0.5;
+/** Fraction of propagated score given back to seed files with many connections. */
+const SELF_BOOST_FACTOR = 0.25;
+/**
+ * Compute import graph proximity scores.
+ * Files that import/are imported by high-scoring files get a boost.
+ * Seed files also get a connectivity bonus based on how many of their
+ * neighbors are in the seed set.
+ */
+export function computeImportGraphScores(db, seedScores, fileIdToChunkIds) {
+    const scores = new Map();
+    try {
+        if (seedScores.size === 0)
+            return scores;
+        // Build fileId → filePath lookup and extension-stripped path index
+        const allFiles = db.getAllFiles();
+        const fileIdToPath = new Map();
+        const pathToFileId = new Map();
+        const strippedToFileId = new Map();
+        for (const f of allFiles) {
+            fileIdToPath.set(f.id, f.filePath);
+            pathToFileId.set(f.filePath, f.id);
+            // Also index without extension so import paths (which strip .js/.ts)
+            // can match stored file paths (which keep the extension)
+            const stripped = stripExtension(f.filePath);
+            if (!strippedToFileId.has(stripped)) {
+                strippedToFileId.set(stripped, f.id);
+            }
+        }
+        /** Resolve an import target path to a fileId. Tries exact match first, then extension-stripped. */
+        function resolveTarget(targetPath) {
+            return pathToFileId.get(targetPath) ?? strippedToFileId.get(targetPath);
+        }
+        // Propagate scores to neighbors
+        const propagated = new Map(); // fileId → accumulated propagated score
+        for (const [fileId, seedScore] of seedScores) {
+            const propagatedScore = seedScore * PROPAGATION_FACTOR;
+            if (propagatedScore <= 0)
+                continue;
+            let connectedSeedCount = 0;
+            // Files this file imports
+            const importedPaths = db.getImportsFrom(fileId);
+            for (const targetPath of importedPaths) {
+                const targetFileId = resolveTarget(targetPath);
+                if (targetFileId === undefined)
+                    continue;
+                if (seedScores.has(targetFileId)) {
+                    connectedSeedCount++;
+                }
+                else {
+                    propagated.set(targetFileId, (propagated.get(targetFileId) ?? 0) + propagatedScore);
+                }
+            }
+            // Files that import this file
+            const filePath = fileIdToPath.get(fileId);
+            if (filePath) {
+                const importerIds = db.getImportersOf(filePath);
+                // Also check extension-stripped variant
+                const stripped = stripExtension(filePath);
+                const strippedImporterIds = stripped !== filePath ? db.getImportersOf(stripped) : [];
+                const allImporterIds = new Set([...importerIds, ...strippedImporterIds]);
+                for (const importerFileId of allImporterIds) {
+                    if (seedScores.has(importerFileId)) {
+                        connectedSeedCount++;
+                    }
+                    else {
+                        propagated.set(importerFileId, (propagated.get(importerFileId) ?? 0) + propagatedScore);
+                    }
+                }
+            }
+            // Self-boost: seed files with many connections to other seeds get a bonus
+            if (connectedSeedCount > 0) {
+                const selfBoost = seedScore * SELF_BOOST_FACTOR * Math.min(connectedSeedCount / 3, 1);
+                propagated.set(fileId, (propagated.get(fileId) ?? 0) + selfBoost);
+            }
+        }
+        if (propagated.size === 0)
+            return scores;
+        // Find max for normalization
+        let maxScore = 0;
+        for (const score of propagated.values()) {
+            if (score > maxScore)
+                maxScore = score;
+        }
+        if (maxScore <= 0)
+            return scores;
+        // Distribute to chunks and normalize
+        for (const [fileId, fileScore] of propagated) {
+            const chunkIds = fileIdToChunkIds.get(fileId);
+            if (!chunkIds || chunkIds.length === 0)
+                continue;
+            // Distribute equally among chunks in this file
+            const perChunkScore = fileScore / maxScore / chunkIds.length;
+            for (const chunkId of chunkIds) {
+                scores.set(chunkId, perChunkScore);
+            }
+        }
+    }
+    catch {
+        // If anything fails, return empty map
+    }
+    return scores;
+}
+/** Strip common source file extensions for path matching. */
+function stripExtension(filePath) {
+    return filePath.replace(/\.[jt]sx?$|\.py$|\.go$|\.rs$|\.java$|\.c$|\.h$|\.cpp$|\.hpp$|\.cc$|\.cxx$/, "");
+}
+//# sourceMappingURL=import-graph.js.map

package/dist/core/search/metrics/import-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-graph.js","sourceRoot":"","sources":["../../../../src/core/search/metrics/import-graph.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Import graph proximity metric.\n *\n * Files that import or are imported by high-scoring files get a boost.\n * Uses a simple 1-hop propagation from seed scores.\n */\n\nimport type { SearchDatabase } from \"../db.js\";\n\n/** Fraction of seed score propagated to neighbors. */\nconst PROPAGATION_FACTOR = 0.5;\n\n/** Fraction of propagated score given back to seed files with many connections. */\nconst SELF_BOOST_FACTOR = 0.25;\n\n/**\n * Compute import graph proximity scores.\n * Files that import/are imported by high-scoring files get a boost.\n * Seed files also get a connectivity bonus based on how many of their\n * neighbors are in the seed set.\n */\nexport function computeImportGraphScores(\n\tdb: SearchDatabase,\n\tseedScores: Map<number, number>,\n\tfileIdToChunkIds: Map<number, number[]>,\n): Map<number, number> {\n\tconst scores = new Map<number, number>();\n\n\ttry {\n\t\tif (seedScores.size === 0) return scores;\n\n\t\t// Build fileId → filePath lookup and extension-stripped path index\n\t\tconst allFiles = db.getAllFiles();\n\t\tconst fileIdToPath = new Map<number, string>();\n\t\tconst pathToFileId = new Map<string, number>();\n\t\tconst strippedToFileId = new Map<string, number>();\n\n\t\tfor (const f of allFiles) {\n\t\t\tfileIdToPath.set(f.id, f.filePath);\n\t\t\tpathToFileId.set(f.filePath, f.id);\n\t\t\t// Also index without extension so import paths (which strip .js/.ts)\n\t\t\t// can match stored file paths (which keep the extension)\n\t\t\tconst stripped = stripExtension(f.filePath);\n\t\t\tif (!strippedToFileId.has(stripped)) {\n\t\t\t\tstrippedToFileId.set(stripped, f.id);\n\t\t\t}\n\t\t}\n\n\t\t/** Resolve an import target path to a fileId. Tries exact match first, then extension-stripped. */\n\t\tfunction resolveTarget(targetPath: string): number | undefined {\n\t\t\treturn pathToFileId.get(targetPath) ?? strippedToFileId.get(targetPath);\n\t\t}\n\n\t\t// Propagate scores to neighbors\n\t\tconst propagated = new Map<number, number>(); // fileId → accumulated propagated score\n\n\t\tfor (const [fileId, seedScore] of seedScores) {\n\t\t\tconst propagatedScore = seedScore * PROPAGATION_FACTOR;\n\t\t\tif (propagatedScore <= 0) continue;\n\n\t\t\tlet connectedSeedCount = 0;\n\n\t\t\t// Files this file imports\n\t\t\tconst importedPaths = db.getImportsFrom(fileId);\n\t\t\tfor (const targetPath of importedPaths) {\n\t\t\t\tconst targetFileId = resolveTarget(targetPath);\n\t\t\t\tif (targetFileId === undefined) continue;\n\n\t\t\t\tif (seedScores.has(targetFileId)) {\n\t\t\t\t\tconnectedSeedCount++;\n\t\t\t\t} else {\n\t\t\t\t\tpropagated.set(targetFileId, (propagated.get(targetFileId) ?? 0) + propagatedScore);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Files that import this file\n\t\t\tconst filePath = fileIdToPath.get(fileId);\n\t\t\tif (filePath) {\n\t\t\t\tconst importerIds = db.getImportersOf(filePath);\n\t\t\t\t// Also check extension-stripped variant\n\t\t\t\tconst stripped = stripExtension(filePath);\n\t\t\t\tconst strippedImporterIds = stripped !== filePath ? db.getImportersOf(stripped) : [];\n\t\t\t\tconst allImporterIds = new Set([...importerIds, ...strippedImporterIds]);\n\n\t\t\t\tfor (const importerFileId of allImporterIds) {\n\t\t\t\t\tif (seedScores.has(importerFileId)) {\n\t\t\t\t\t\tconnectedSeedCount++;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tpropagated.set(importerFileId, (propagated.get(importerFileId) ?? 0) + propagatedScore);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Self-boost: seed files with many connections to other seeds get a bonus\n\t\t\tif (connectedSeedCount > 0) {\n\t\t\t\tconst selfBoost = seedScore * SELF_BOOST_FACTOR * Math.min(connectedSeedCount / 3, 1);\n\t\t\t\tpropagated.set(fileId, (propagated.get(fileId) ?? 0) + selfBoost);\n\t\t\t}\n\t\t}\n\n\t\tif (propagated.size === 0) return scores;\n\n\t\t// Find max for normalization\n\t\tlet maxScore = 0;\n\t\tfor (const score of propagated.values()) {\n\t\t\tif (score > maxScore) maxScore = score;\n\t\t}\n\n\t\tif (maxScore <= 0) return scores;\n\n\t\t// Distribute to chunks and normalize\n\t\tfor (const [fileId, fileScore] of propagated) {\n\t\t\tconst chunkIds = fileIdToChunkIds.get(fileId);\n\t\t\tif (!chunkIds || chunkIds.length === 0) continue;\n\n\t\t\t// Distribute equally among chunks in this file\n\t\t\tconst perChunkScore = fileScore / maxScore / chunkIds.length;\n\t\t\tfor (const chunkId of chunkIds) {\n\t\t\t\tscores.set(chunkId, perChunkScore);\n\t\t\t}\n\t\t}\n\t} catch {\n\t\t// If anything fails, return empty map\n\t}\n\n\treturn scores;\n}\n\n/** Strip common source file extensions for path matching. */\nfunction stripExtension(filePath: string): string {\n\treturn filePath.replace(/\\.[jt]sx?$|\\.py$|\\.go$|\\.rs$|\\.java$|\\.c$|\\.h$|\\.cpp$|\\.hpp$|\\.cc$|\\.cxx$/, \"\");\n}\n"]}

package/dist/core/search/metrics/path-match.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Path/filename similarity metric.
+ *
+ * Tokenizes query and file paths, computes a recall-oriented overlap score
+ * (what fraction of query tokens appear in the path).
+ */
+import type { StoredChunk } from "../types.js";
+/**
+ * Compute path/filename similarity scores.
+ * Tokenizes query and file paths, returns Jaccard-like overlap score.
+ */
+export declare function computePathMatchScores(query: string, chunks: StoredChunk[]): Map<number, number>;
+//# sourceMappingURL=path-match.d.ts.map

package/dist/core/search/metrics/path-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-match.d.ts","sourceRoot":"","sources":["../../../../src/core/search/metrics/path-match.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA+ChG","sourcesContent":["/**\n * Path/filename similarity metric.\n *\n * Tokenizes query and file paths, computes a recall-oriented overlap score\n * (what fraction of query tokens appear in the path).\n */\n\nimport type { StoredChunk } from \"../types.js\";\nimport { tokenize } from \"./tokenize.js\";\n\n/**\n * Compute path/filename similarity scores.\n * Tokenizes query and file paths, returns Jaccard-like overlap score.\n */\nexport function computePathMatchScores(query: string, chunks: StoredChunk[]): Map<number, number> {\n\tconst scores = new Map<number, number>();\n\n\ttry {\n\t\tconst queryTokens = tokenize(query);\n\t\tif (queryTokens.length === 0) return scores;\n\n\t\tconst querySet = new Set(queryTokens);\n\n\t\t// Cache path tokens per file path (many chunks share the same file)\n\t\tconst pathTokenCache = new Map<string, Set<string>>();\n\n\t\tlet maxScore = 0;\n\n\t\tfor (const chunk of chunks) {\n\t\t\tlet pathTokenSet = pathTokenCache.get(chunk.filePath);\n\t\t\tif (!pathTokenSet) {\n\t\t\t\tpathTokenSet = new Set(tokenize(chunk.filePath));\n\t\t\t\tpathTokenCache.set(chunk.filePath, pathTokenSet);\n\t\t\t}\n\n\t\t\t// Score = |intersection| / |query tokens| (recall-oriented)\n\t\t\tlet intersection = 0;\n\t\t\tfor (const qt of querySet) {\n\t\t\t\tif (pathTokenSet.has(qt)) {\n\t\t\t\t\tintersection++;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tconst score = intersection / queryTokens.length;\n\t\t\tif (score > 0) {\n\t\t\t\tscores.set(chunk.id, score);\n\t\t\t\tif (score > maxScore) maxScore = score;\n\t\t\t}\n\t\t}\n\n\t\t// Normalize to 0-1 (divide by max if not already bounded)\n\t\tif (maxScore > 0 && maxScore !== 1) {\n\t\t\tfor (const [id, score] of scores) {\n\t\t\t\tscores.set(id, score / maxScore);\n\t\t\t}\n\t\t}\n\t} catch {\n\t\t// If anything fails, return empty map\n\t}\n\n\treturn scores;\n}\n"]}

package/dist/core/search/metrics/path-match.js

@@ -0,0 +1,54 @@
+/**
+ * Path/filename similarity metric.
+ *
+ * Tokenizes query and file paths, computes a recall-oriented overlap score
+ * (what fraction of query tokens appear in the path).
+ */
+import { tokenize } from "./tokenize.js";
+/**
+ * Compute path/filename similarity scores.
+ * Tokenizes query and file paths, returns Jaccard-like overlap score.
+ */
+export function computePathMatchScores(query, chunks) {
+    const scores = new Map();
+    try {
+        const queryTokens = tokenize(query);
+        if (queryTokens.length === 0)
+            return scores;
+        const querySet = new Set(queryTokens);
+        // Cache path tokens per file path (many chunks share the same file)
+        const pathTokenCache = new Map();
+        let maxScore = 0;
+        for (const chunk of chunks) {
+            let pathTokenSet = pathTokenCache.get(chunk.filePath);
+            if (!pathTokenSet) {
+                pathTokenSet = new Set(tokenize(chunk.filePath));
+                pathTokenCache.set(chunk.filePath, pathTokenSet);
+            }
+            // Score = |intersection| / |query tokens| (recall-oriented)
+            let intersection = 0;
+            for (const qt of querySet) {
+                if (pathTokenSet.has(qt)) {
+                    intersection++;
+                }
+            }
+            const score = intersection / queryTokens.length;
+            if (score > 0) {
+                scores.set(chunk.id, score);
+                if (score > maxScore)
+                    maxScore = score;
+            }
+        }
+        // Normalize to 0-1 (divide by max if not already bounded)
+        if (maxScore > 0 && maxScore !== 1) {
+            for (const [id, score] of scores) {
+                scores.set(id, score / maxScore);
+            }
+        }
+    }
+    catch {
+        // If anything fails, return empty map
+    }
+    return scores;
+}
+//# sourceMappingURL=path-match.js.map

package/dist/core/search/metrics/path-match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-match.js","sourceRoot":"","sources":["../../../../src/core/search/metrics/path-match.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAa,EAAE,MAAqB,EAAuB;IACjG,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;IAEzC,IAAI,CAAC;QACJ,MAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QACpC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,MAAM,CAAC;QAE5C,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC;QAEtC,oEAAoE;QACpE,MAAM,cAAc,GAAG,IAAI,GAAG,EAAuB,CAAC;QAEtD,IAAI,QAAQ,GAAG,CAAC,CAAC;QAEjB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC5B,IAAI,YAAY,GAAG,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YACtD,IAAI,CAAC,YAAY,EAAE,CAAC;gBACnB,YAAY,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;gBACjD,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;YAClD,CAAC;YAED,4DAA4D;YAC5D,IAAI,YAAY,GAAG,CAAC,CAAC;YACrB,KAAK,MAAM,EAAE,IAAI,QAAQ,EAAE,CAAC;gBAC3B,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;oBAC1B,YAAY,EAAE,CAAC;gBAChB,CAAC;YACF,CAAC;YAED,MAAM,KAAK,GAAG,YAAY,GAAG,WAAW,CAAC,MAAM,CAAC;YAChD,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;gBACf,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;gBAC5B,IAAI,KAAK,GAAG,QAAQ;oBAAE,QAAQ,GAAG,KAAK,CAAC;YACxC,CAAC;QACF,CAAC;QAED,0DAA0D;QAC1D,IAAI,QAAQ,GAAG,CAAC,IAAI,QAAQ,KAAK,CAAC,EAAE,CAAC;YACpC,KAAK,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,MAAM,EAAE,CAAC;gBAClC,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,GAAG,QAAQ,CAAC,CAAC;YAClC,CAAC;QACF,CAAC;IACF,CAAC;IAAC,MAAM,CAAC;QACR,sCAAsC;IACvC,CAAC;IAED,OAAO,MAAM,CAAC;AAAA,CACd","sourcesContent":["/**\n * Path/filename similarity metric.\n *\n * Tokenizes query and file paths, computes a recall-oriented overlap score\n * (what fraction of query tokens appear in the path).\n */\n\nimport type { StoredChunk } from \"../types.js\";\nimport { tokenize } from \"./tokenize.js\";\n\n/**\n * Compute path/filename similarity scores.\n * Tokenizes query and file paths, returns Jaccard-like overlap score.\n */\nexport function computePathMatchScores(query: string, chunks: StoredChunk[]): Map<number, number> {\n\tconst scores = new Map<number, number>();\n\n\ttry {\n\t\tconst queryTokens = tokenize(query);\n\t\tif (queryTokens.length === 0) return scores;\n\n\t\tconst querySet = new Set(queryTokens);\n\n\t\t// Cache path tokens per file path (many chunks share the same file)\n\t\tconst pathTokenCache = new Map<string, Set<string>>();\n\n\t\tlet maxScore = 0;\n\n\t\tfor (const chunk of chunks) {\n\t\t\tlet pathTokenSet = pathTokenCache.get(chunk.filePath);\n\t\t\tif (!pathTokenSet) {\n\t\t\t\tpathTokenSet = new Set(tokenize(chunk.filePath));\n\t\t\t\tpathTokenCache.set(chunk.filePath, pathTokenSet);\n\t\t\t}\n\n\t\t\t// Score = |intersection| / |query tokens| (recall-oriented)\n\t\t\tlet intersection = 0;\n\t\t\tfor (const qt of querySet) {\n\t\t\t\tif (pathTokenSet.has(qt)) {\n\t\t\t\t\tintersection++;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tconst score = intersection / queryTokens.length;\n\t\t\tif (score > 0) {\n\t\t\t\tscores.set(chunk.id, score);\n\t\t\t\tif (score > maxScore) maxScore = score;\n\t\t\t}\n\t\t}\n\n\t\t// Normalize to 0-1 (divide by max if not already bounded)\n\t\tif (maxScore > 0 && maxScore !== 1) {\n\t\t\tfor (const [id, score] of scores) {\n\t\t\t\tscores.set(id, score / maxScore);\n\t\t\t}\n\t\t}\n\t} catch {\n\t\t// If anything fails, return empty map\n\t}\n\n\treturn scores;\n}\n"]}

package/dist/core/search/metrics/symbol-match.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Symbol name match metric.
+ *
+ * Compares query terms against symbol names (function/class/etc names)
+ * using tokenized overlap with bonuses for exact substring matches.
+ */
+/**
+ * Compute symbol name match scores.
+ * Compares query terms against symbol names (function/class/etc names).
+ */
+export declare function computeSymbolMatchScores(query: string, symbols: Map<number, string[]>): Map<number, number>;
+//# sourceMappingURL=symbol-match.d.ts.map

package/dist/core/search/metrics/symbol-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-match.d.ts","sourceRoot":"","sources":["../../../../src/core/search/metrics/symbol-match.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAyD3G","sourcesContent":["/**\n * Symbol name match metric.\n *\n * Compares query terms against symbol names (function/class/etc names)\n * using tokenized overlap with bonuses for exact substring matches.\n */\n\nimport { tokenize } from \"./tokenize.js\";\n\n/**\n * Compute symbol name match scores.\n * Compares query terms against symbol names (function/class/etc names).\n */\nexport function computeSymbolMatchScores(query: string, symbols: Map<number, string[]>): Map<number, number> {\n\tconst scores = new Map<number, number>();\n\n\ttry {\n\t\tconst queryTokens = tokenize(query);\n\t\tif (queryTokens.length === 0) return scores;\n\n\t\tconst queryLower = query.toLowerCase();\n\n\t\tlet maxScore = 0;\n\n\t\tfor (const [chunkId, symbolNames] of symbols) {\n\t\t\tlet bestScore = 0;\n\n\t\t\tfor (const symbolName of symbolNames) {\n\t\t\t\tconst symbolTokens = new Set(tokenize(symbolName));\n\t\t\t\tconst symbolLower = symbolName.toLowerCase();\n\n\t\t\t\t// Token overlap: fraction of query tokens found in symbol\n\t\t\t\tlet matchCount = 0;\n\t\t\t\tfor (const qt of queryTokens) {\n\t\t\t\t\tif (symbolTokens.has(qt)) {\n\t\t\t\t\t\tmatchCount++;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tlet score = matchCount / queryTokens.length;\n\n\t\t\t\t// Bonus for exact substring match of query in symbol name\n\t\t\t\tif (symbolLower.includes(queryLower)) {\n\t\t\t\t\tscore = Math.min(1, score + 0.3);\n\t\t\t\t}\n\t\t\t\t// Bonus for exact substring match of symbol in query\n\t\t\t\telse if (queryLower.includes(symbolLower) && symbolLower.length >= 3) {\n\t\t\t\t\tscore = Math.min(1, score + 0.2);\n\t\t\t\t}\n\n\t\t\t\tif (score > bestScore) bestScore = score;\n\t\t\t}\n\n\t\t\tif (bestScore > 0) {\n\t\t\t\tscores.set(chunkId, bestScore);\n\t\t\t\tif (bestScore > maxScore) maxScore = bestScore;\n\t\t\t}\n\t\t}\n\n\t\t// Normalize to 0-1\n\t\tif (maxScore > 0 && maxScore !== 1) {\n\t\t\tfor (const [id, score] of scores) {\n\t\t\t\tscores.set(id, score / maxScore);\n\t\t\t}\n\t\t}\n\t} catch {\n\t\t// If anything fails, return empty map\n\t}\n\n\treturn scores;\n}\n"]}

package/dist/core/search/metrics/symbol-match.js

@@ -0,0 +1,62 @@
+/**
+ * Symbol name match metric.
+ *
+ * Compares query terms against symbol names (function/class/etc names)
+ * using tokenized overlap with bonuses for exact substring matches.
+ */
+import { tokenize } from "./tokenize.js";
+/**
+ * Compute symbol name match scores.
+ * Compares query terms against symbol names (function/class/etc names).
+ */
+export function computeSymbolMatchScores(query, symbols) {
+    const scores = new Map();
+    try {
+        const queryTokens = tokenize(query);
+        if (queryTokens.length === 0)
+            return scores;
+        const queryLower = query.toLowerCase();
+        let maxScore = 0;
+        for (const [chunkId, symbolNames] of symbols) {
+            let bestScore = 0;
+            for (const symbolName of symbolNames) {
+                const symbolTokens = new Set(tokenize(symbolName));
+                const symbolLower = symbolName.toLowerCase();
+                // Token overlap: fraction of query tokens found in symbol
+                let matchCount = 0;
+                for (const qt of queryTokens) {
+                    if (symbolTokens.has(qt)) {
+                        matchCount++;
+                    }
+                }
+                let score = matchCount / queryTokens.length;
+                // Bonus for exact substring match of query in symbol name
+                if (symbolLower.includes(queryLower)) {
+                    score = Math.min(1, score + 0.3);
+                }
+                // Bonus for exact substring match of symbol in query
+                else if (queryLower.includes(symbolLower) && symbolLower.length >= 3) {
+                    score = Math.min(1, score + 0.2);
+                }
+                if (score > bestScore)
+                    bestScore = score;
+            }
+            if (bestScore > 0) {
+                scores.set(chunkId, bestScore);
+                if (bestScore > maxScore)
+                    maxScore = bestScore;
+            }
+        }
+        // Normalize to 0-1
+        if (maxScore > 0 && maxScore !== 1) {
+            for (const [id, score] of scores) {
+                scores.set(id, score / maxScore);
+            }
+        }
+    }
+    catch {
+        // If anything fails, return empty map
+    }
+    return scores;
+}
+//# sourceMappingURL=symbol-match.js.map

package/dist/core/search/metrics/symbol-match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-match.js","sourceRoot":"","sources":["../../../../src/core/search/metrics/symbol-match.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CAAC,KAAa,EAAE,OAA8B,EAAuB;IAC5G,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;IAEzC,IAAI,CAAC;QACJ,MAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QACpC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,MAAM,CAAC;QAE5C,MAAM,UAAU,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;QAEvC,IAAI,QAAQ,GAAG,CAAC,CAAC;QAEjB,KAAK,MAAM,CAAC,OAAO,EAAE,WAAW,CAAC,IAAI,OAAO,EAAE,CAAC;YAC9C,IAAI,SAAS,GAAG,CAAC,CAAC;YAElB,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;gBACtC,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;gBACnD,MAAM,WAAW,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC;gBAE7C,0DAA0D;gBAC1D,IAAI,UAAU,GAAG,CAAC,CAAC;gBACnB,KAAK,MAAM,EAAE,IAAI,WAAW,EAAE,CAAC;oBAC9B,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;wBAC1B,UAAU,EAAE,CAAC;oBACd,CAAC;gBACF,CAAC;gBAED,IAAI,KAAK,GAAG,UAAU,GAAG,WAAW,CAAC,MAAM,CAAC;gBAE5C,0DAA0D;gBAC1D,IAAI,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;oBACtC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,GAAG,CAAC,CAAC;gBAClC,CAAC;gBACD,qDAAqD;qBAChD,IAAI,UAAU,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;oBACtE,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,GAAG,CAAC,CAAC;gBAClC,CAAC;gBAED,IAAI,KAAK,GAAG,SAAS;oBAAE,SAAS,GAAG,KAAK,CAAC;YAC1C,CAAC;YAED,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;gBACnB,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;gBAC/B,IAAI,SAAS,GAAG,QAAQ;oBAAE,QAAQ,GAAG,SAAS,CAAC;YAChD,CAAC;QACF,CAAC;QAED,mBAAmB;QACnB,IAAI,QAAQ,GAAG,CAAC,IAAI,QAAQ,KAAK,CAAC,EAAE,CAAC;YACpC,KAAK,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,MAAM,EAAE,CAAC;gBAClC,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,GAAG,QAAQ,CAAC,CAAC;YAClC,CAAC;QACF,CAAC;IACF,CAAC;IAAC,MAAM,CAAC;QACR,sCAAsC;IACvC,CAAC;IAED,OAAO,MAAM,CAAC;AAAA,CACd","sourcesContent":["/**\n * Symbol name match metric.\n *\n * Compares query terms against symbol names (function/class/etc names)\n * using tokenized overlap with bonuses for exact substring matches.\n */\n\nimport { tokenize } from \"./tokenize.js\";\n\n/**\n * Compute symbol name match scores.\n * Compares query terms against symbol names (function/class/etc names).\n */\nexport function computeSymbolMatchScores(query: string, symbols: Map<number, string[]>): Map<number, number> {\n\tconst scores = new Map<number, number>();\n\n\ttry {\n\t\tconst queryTokens = tokenize(query);\n\t\tif (queryTokens.length === 0) return scores;\n\n\t\tconst queryLower = query.toLowerCase();\n\n\t\tlet maxScore = 0;\n\n\t\tfor (const [chunkId, symbolNames] of symbols) {\n\t\t\tlet bestScore = 0;\n\n\t\t\tfor (const symbolName of symbolNames) {\n\t\t\t\tconst symbolTokens = new Set(tokenize(symbolName));\n\t\t\t\tconst symbolLower = symbolName.toLowerCase();\n\n\t\t\t\t// Token overlap: fraction of query tokens found in symbol\n\t\t\t\tlet matchCount = 0;\n\t\t\t\tfor (const qt of queryTokens) {\n\t\t\t\t\tif (symbolTokens.has(qt)) {\n\t\t\t\t\t\tmatchCount++;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tlet score = matchCount / queryTokens.length;\n\n\t\t\t\t// Bonus for exact substring match of query in symbol name\n\t\t\t\tif (symbolLower.includes(queryLower)) {\n\t\t\t\t\tscore = Math.min(1, score + 0.3);\n\t\t\t\t}\n\t\t\t\t// Bonus for exact substring match of symbol in query\n\t\t\t\telse if (queryLower.includes(symbolLower) && symbolLower.length >= 3) {\n\t\t\t\t\tscore = Math.min(1, score + 0.2);\n\t\t\t\t}\n\n\t\t\t\tif (score > bestScore) bestScore = score;\n\t\t\t}\n\n\t\t\tif (bestScore > 0) {\n\t\t\t\tscores.set(chunkId, bestScore);\n\t\t\t\tif (bestScore > maxScore) maxScore = bestScore;\n\t\t\t}\n\t\t}\n\n\t\t// Normalize to 0-1\n\t\tif (maxScore > 0 && maxScore !== 1) {\n\t\t\tfor (const [id, score] of scores) {\n\t\t\t\tscores.set(id, score / maxScore);\n\t\t\t}\n\t\t}\n\t} catch {\n\t\t// If anything fails, return empty map\n\t}\n\n\treturn scores;\n}\n"]}

package/dist/core/search/metrics/tokenize.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared tokenizer for path-match and symbol-match metrics.
+ *
+ * Splits text on common code boundaries (spaces, path separators, dots,
+ * dashes, underscores, camelCase) and normalizes to lowercase.
+ */
+/**
+ * Tokenize text by splitting on spaces, `/`, `\`, `.`, `-`, `_`, and
+ * camelCase boundaries. Returns unique, lowercase tokens ≥ 2 chars.
+ */
+export declare function tokenize(text: string): string[];
+//# sourceMappingURL=tokenize.d.ts.map

package/dist/core/search/metrics/tokenize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.d.ts","sourceRoot":"","sources":["../../../../src/core/search/metrics/tokenize.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAoB/C","sourcesContent":["/**\n * Shared tokenizer for path-match and symbol-match metrics.\n *\n * Splits text on common code boundaries (spaces, path separators, dots,\n * dashes, underscores, camelCase) and normalizes to lowercase.\n */\n\n/**\n * Tokenize text by splitting on spaces, `/`, `\\`, `.`, `-`, `_`, and\n * camelCase boundaries. Returns unique, lowercase tokens ≥ 2 chars.\n */\nexport function tokenize(text: string): string[] {\n\t// Insert a space before uppercase letters that follow lowercase letters (camelCase)\n\t// or before uppercase letters followed by lowercase (e.g., \"XMLParser\" → \"XML Parser\")\n\tconst spaced = text.replace(/([a-z])([A-Z])/g, \"$1 $2\").replace(/([A-Z]+)([A-Z][a-z])/g, \"$1 $2\");\n\n\t// Split on common delimiters\n\tconst parts = spaced.split(/[\\s/\\\\.\\-_]+/);\n\n\t// Lowercase, deduplicate, filter short tokens\n\tconst seen = new Set<string>();\n\tconst tokens: string[] = [];\n\tfor (const part of parts) {\n\t\tconst lower = part.toLowerCase();\n\t\tif (lower.length >= 2 && !seen.has(lower)) {\n\t\t\tseen.add(lower);\n\t\t\ttokens.push(lower);\n\t\t}\n\t}\n\n\treturn tokens;\n}\n"]}

package/dist/core/search/metrics/tokenize.js

@@ -0,0 +1,29 @@
+/**
+ * Shared tokenizer for path-match and symbol-match metrics.
+ *
+ * Splits text on common code boundaries (spaces, path separators, dots,
+ * dashes, underscores, camelCase) and normalizes to lowercase.
+ */
+/**
+ * Tokenize text by splitting on spaces, `/`, `\`, `.`, `-`, `_`, and
+ * camelCase boundaries. Returns unique, lowercase tokens ≥ 2 chars.
+ */
+export function tokenize(text) {
+    // Insert a space before uppercase letters that follow lowercase letters (camelCase)
+    // or before uppercase letters followed by lowercase (e.g., "XMLParser" → "XML Parser")
+    const spaced = text.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2");
+    // Split on common delimiters
+    const parts = spaced.split(/[\s/\\.\-_]+/);
+    // Lowercase, deduplicate, filter short tokens
+    const seen = new Set();
+    const tokens = [];
+    for (const part of parts) {
+        const lower = part.toLowerCase();
+        if (lower.length >= 2 && !seen.has(lower)) {
+            seen.add(lower);
+            tokens.push(lower);
+        }
+    }
+    return tokens;
+}
+//# sourceMappingURL=tokenize.js.map

package/dist/core/search/metrics/tokenize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.js","sourceRoot":"","sources":["../../../../src/core/search/metrics/tokenize.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAY,EAAY;IAChD,oFAAoF;IACpF,yFAAuF;IACvF,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,uBAAuB,EAAE,OAAO,CAAC,CAAC;IAElG,6BAA6B;IAC7B,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IAE3C,8CAA8C;IAC9C,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACjC,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAC3C,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAChB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpB,CAAC;IACF,CAAC;IAED,OAAO,MAAM,CAAC;AAAA,CACd","sourcesContent":["/**\n * Shared tokenizer for path-match and symbol-match metrics.\n *\n * Splits text on common code boundaries (spaces, path separators, dots,\n * dashes, underscores, camelCase) and normalizes to lowercase.\n */\n\n/**\n * Tokenize text by splitting on spaces, `/`, `\\`, `.`, `-`, `_`, and\n * camelCase boundaries. Returns unique, lowercase tokens ≥ 2 chars.\n */\nexport function tokenize(text: string): string[] {\n\t// Insert a space before uppercase letters that follow lowercase letters (camelCase)\n\t// or before uppercase letters followed by lowercase (e.g., \"XMLParser\" → \"XML Parser\")\n\tconst spaced = text.replace(/([a-z])([A-Z])/g, \"$1 $2\").replace(/([A-Z]+)([A-Z][a-z])/g, \"$1 $2\");\n\n\t// Split on common delimiters\n\tconst parts = spaced.split(/[\\s/\\\\.\\-_]+/);\n\n\t// Lowercase, deduplicate, filter short tokens\n\tconst seen = new Set<string>();\n\tconst tokens: string[] = [];\n\tfor (const part of parts) {\n\t\tconst lower = part.toLowerCase();\n\t\tif (lower.length >= 2 && !seen.has(lower)) {\n\t\t\tseen.add(lower);\n\t\t\ttokens.push(lower);\n\t\t}\n\t}\n\n\treturn tokens;\n}\n"]}

package/dist/core/search/poem.d.ts

@@ -0,0 +1,38 @@
+/**
+ * POEM — Pareto-Optimal Embedded Modeling, multi-metric ranking.
+ *
+ * Ranks search candidates across multiple relevance metrics without requiring
+ * hand-tuned weights. Uses the TFPR (Top-Fraction Pareto Ranker) approach:
+ * vectorized dominance matrix computation with column duplication for
+ * query-type-dependent metric weighting.
+ *
+ * Algorithm:
+ *  1. Prune: per-metric top-K → union of survivors
+ *  2. Build objectives matrix with column duplication for query-type weighting
+ *  3. For each objective column, sort candidates and accumulate pairwise
+ *     dominance counts (duplicate columns contribute via weight multiplier)
+ *  4. Compute fitness: meanDominance × (numDominating + ε) / (numSubmitting + ε)
+ *  5. Sort by fitness, assign ranks
+ *
+ * References:
+ *  - POEM paper: https://iopscience.iop.org/article/10.1088/2632-2153/ab891b
+ *  - TFPR: https://github.com/merckgroup/aidd_tfpr
+ *  - colourdle: https://github.com/aebrer/colourdle
+ */
+import type { QueryType } from "./query-classifier.js";
+import { type MetricScores } from "./types.js";
+export interface RankedCandidate {
+    id: number;
+    scores: MetricScores;
+    rank: number;
+}
+/**
+ * Rank candidates using POEM / TFPR.
+ *
+ * @param candidates Map of candidateId → MetricScores (all values 0–1)
+ * @param queryType  Query type for column duplication weighting
+ * @param topK       Per-metric pruning limit (default: 1000)
+ * @returns Candidates ordered best-first with assigned ranks (0 = best)
+ */
+export declare function poemRank(candidates: Map<number, MetricScores>, queryType: QueryType, topK?: number): RankedCandidate[];
+//# sourceMappingURL=poem.d.ts.map

package/dist/core/search/poem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poem.d.ts","sourceRoot":"","sources":["../../../src/core/search/poem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAiC,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAM9E,MAAM,WAAW,eAAe;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,YAAY,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACb;AA4KD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,SAAO,GAAG,eAAe,EAAE,CA+CpH","sourcesContent":["/**\n * POEM — Pareto-Optimal Embedded Modeling, multi-metric ranking.\n *\n * Ranks search candidates across multiple relevance metrics without requiring\n * hand-tuned weights. Uses the TFPR (Top-Fraction Pareto Ranker) approach:\n * vectorized dominance matrix computation with column duplication for\n * query-type-dependent metric weighting.\n *\n * Algorithm:\n *  1. Prune: per-metric top-K → union of survivors\n *  2. Build objectives matrix with column duplication for query-type weighting\n *  3. For each objective column, sort candidates and accumulate pairwise\n *     dominance counts (duplicate columns contribute via weight multiplier)\n *  4. Compute fitness: meanDominance × (numDominating + ε) / (numSubmitting + ε)\n *  5. Sort by fitness, assign ranks\n *\n * References:\n *  - POEM paper: https://iopscience.iop.org/article/10.1088/2632-2153/ab891b\n *  - TFPR: https://github.com/merckgroup/aidd_tfpr\n *  - colourdle: https://github.com/aebrer/colourdle\n */\n\nimport type { QueryType } from \"./query-classifier.js\";\nimport { METRIC_NAMES, type MetricName, type MetricScores } from \"./types.js\";\n\n// ============================================================================\n// Public types\n// ============================================================================\n\nexport interface RankedCandidate {\n\tid: number;\n\tscores: MetricScores;\n\trank: number;\n}\n\n// ============================================================================\n// Column duplication config per query type\n// ============================================================================\n\n/** How many times each metric column appears in the objectives matrix. */\ntype ColumnWeights = Record<MetricName, number>;\n\nconst COLUMN_WEIGHTS: Record<QueryType, ColumnWeights> = {\n\tidentifier: {\n\t\tbm25: 2,\n\t\tcosine: 1,\n\t\tpathMatch: 1,\n\t\tsymbolMatch: 2,\n\t\timportGraph: 1,\n\t\tgitRecency: 1,\n\t},\n\tnatural_language: {\n\t\tbm25: 1,\n\t\tcosine: 2,\n\t\tpathMatch: 1,\n\t\tsymbolMatch: 1,\n\t\timportGraph: 1,\n\t\tgitRecency: 1,\n\t},\n\tpath_like: {\n\t\tbm25: 1,\n\t\tcosine: 1,\n\t\tpathMatch: 3,\n\t\tsymbolMatch: 1,\n\t\timportGraph: 1,\n\t\tgitRecency: 1,\n\t},\n};\n\n// ============================================================================\n// Fitness smoothing constant (avoids division by zero)\n// ============================================================================\n\nconst EPSILON = 0.05;\n\n// ============================================================================\n// Pruning\n// ============================================================================\n\n/**\n * Per-metric top-K pruning → union of surviving candidate IDs.\n */\nfunction pruneTopK(candidates: Map<number, MetricScores>, topK: number): Set<number> {\n\tif (candidates.size <= topK) {\n\t\treturn new Set(candidates.keys());\n\t}\n\n\tconst union = new Set<number>();\n\n\tfor (const metric of METRIC_NAMES) {\n\t\tconst pairs: Array<[number, number]> = [];\n\t\tfor (const [id, scores] of candidates) {\n\t\t\tpairs.push([id, scores[metric] ?? 0]);\n\t\t}\n\t\tpairs.sort((a, b) => b[1] - a[1]);\n\t\tconst limit = Math.min(topK, pairs.length);\n\t\tfor (let i = 0; i < limit; i++) {\n\t\t\tunion.add(pairs[i][0]);\n\t\t}\n\t}\n\n\treturn union;\n}\n\n// ============================================================================\n// Dominance matrix computation\n// ============================================================================\n\n/**\n * Build the dominance count matrix using the TFPR approach.\n *\n * For each objective (metric), sorts candidates and accumulates pairwise\n * dominance: if candidate i ranks above candidate j on an objective,\n * dominanceCounts[i][j] increases by the column weight.\n *\n * Duplicate columns (from column duplication) are handled by multiplying\n * the contribution by the weight rather than re-sorting — same result,\n * no redundant work.\n *\n * Uses Uint16Array to keep memory compact (max possible value per cell\n * is the sum of all weights, which is ≤ 10).\n *\n * @param scores  Dense array of MetricScores, indexed 0..n-1\n * @param weights Column weights from query type\n * @param topK    Only top-K per objective contribute to pairwise dominance\n * @returns Flat dominance count matrix [n × n] and the total weight sum\n */\nfunction buildDominanceCounts(\n\tscores: MetricScores[],\n\tweights: ColumnWeights,\n\ttopK: number,\n): [counts: Uint16Array, totalWeight: number] {\n\tconst n = scores.length;\n\tconst counts = new Uint16Array(n * n);\n\tlet totalWeight = 0;\n\n\t// Reusable index array for sorting\n\tconst indices = new Array<number>(n);\n\tfor (let i = 0; i < n; i++) indices[i] = i;\n\n\tfor (const metric of METRIC_NAMES) {\n\t\tconst weight = weights[metric];\n\t\tif (weight === 0) continue;\n\t\ttotalWeight += weight;\n\n\t\t// Sort candidates by this metric (descending)\n\t\tconst sorted = indices.slice();\n\t\tsorted.sort((a, b) => (scores[b][metric] ?? 0) - (scores[a][metric] ?? 0));\n\n\t\t// Only consider top-K for pairwise dominance\n\t\tconst k = Math.min(topK, n);\n\n\t\t// For each pair in the top-K where i ranks above j:\n\t\t// i dominates j on this objective → add weight to counts[i, j]\n\t\tfor (let ri = 0; ri < k; ri++) {\n\t\t\tconst i = sorted[ri];\n\t\t\tconst iBase = i * n;\n\t\t\tfor (let rj = ri + 1; rj < k; rj++) {\n\t\t\t\tcounts[iBase + sorted[rj]] += weight;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn [counts, totalWeight];\n}\n\n/**\n * Compute fitness scores from the dominance count matrix.\n *\n * Fitness = meanDominance × (numDominating + ε) / (numSubmitting + ε)\n *\n * Where:\n *  - meanDominance = average normalized dominance across all other candidates\n *  - numDominating = count of candidates this one dominates (>50% of objectives)\n *  - numSubmitting = count of candidates this one fails to dominate (<50%)\n */\nfunction computeFitness(counts: Uint16Array, n: number, totalWeight: number): Float64Array {\n\tconst fitness = new Float64Array(n);\n\tconst threshold = totalWeight * 0.5;\n\n\tfor (let i = 0; i < n; i++) {\n\t\tlet sumDom = 0;\n\t\tlet numDominating = 0;\n\t\tlet numSubmitting = 0;\n\t\tconst iBase = i * n;\n\n\t\tfor (let j = 0; j < n; j++) {\n\t\t\tif (i === j) continue;\n\t\t\tconst count = counts[iBase + j];\n\t\t\tsumDom += count;\n\t\t\tif (count > threshold) numDominating++;\n\t\t\tif (count < threshold) numSubmitting++;\n\t\t}\n\n\t\tconst meanDom = n > 1 ? sumDom / ((n - 1) * totalWeight) : 0;\n\t\tfitness[i] = (meanDom * (numDominating + EPSILON)) / (numSubmitting + EPSILON);\n\t}\n\n\treturn fitness;\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\n/**\n * Rank candidates using POEM / TFPR.\n *\n * @param candidates Map of candidateId → MetricScores (all values 0–1)\n * @param queryType  Query type for column duplication weighting\n * @param topK       Per-metric pruning limit (default: 1000)\n * @returns Candidates ordered best-first with assigned ranks (0 = best)\n */\nexport function poemRank(candidates: Map<number, MetricScores>, queryType: QueryType, topK = 1000): RankedCandidate[] {\n\tif (candidates.size === 0) return [];\n\n\t// 1. Prune: per-metric top-K → union\n\tconst surviving = pruneTopK(candidates, topK);\n\n\t// 2. Build dense arrays\n\tconst ids: number[] = [];\n\tconst scores: MetricScores[] = [];\n\n\tfor (const id of surviving) {\n\t\tconst s = candidates.get(id)!;\n\t\tids.push(id);\n\t\tscores.push({\n\t\t\tbm25: s.bm25 ?? 0,\n\t\t\tcosine: s.cosine ?? 0,\n\t\t\tpathMatch: s.pathMatch ?? 0,\n\t\t\tsymbolMatch: s.symbolMatch ?? 0,\n\t\t\timportGraph: s.importGraph ?? 0,\n\t\t\tgitRecency: s.gitRecency ?? 0,\n\t\t});\n\t}\n\n\tconst n = ids.length;\n\n\t// Single candidate → rank 0\n\tif (n === 1) {\n\t\treturn [{ id: ids[0], scores: scores[0], rank: 0 }];\n\t}\n\n\t// 3. Compute dominance matrix with column duplication\n\tconst weights = COLUMN_WEIGHTS[queryType];\n\tconst [counts, totalWeight] = buildDominanceCounts(scores, weights, topK);\n\n\t// 4. Compute fitness scores\n\tconst fitness = computeFitness(counts, n, totalWeight);\n\n\t// 5. Sort by fitness (descending) and assign ranks\n\tconst order = new Array<number>(n);\n\tfor (let i = 0; i < n; i++) order[i] = i;\n\torder.sort((a, b) => fitness[b] - fitness[a]);\n\n\treturn order.map((idx, rank) => ({\n\t\tid: ids[idx],\n\t\tscores: scores[idx],\n\t\trank,\n\t}));\n}\n"]}

package/dist/core/search/poem.js

@@ -0,0 +1,214 @@
+/**
+ * POEM — Pareto-Optimal Embedded Modeling, multi-metric ranking.
+ *
+ * Ranks search candidates across multiple relevance metrics without requiring
+ * hand-tuned weights. Uses the TFPR (Top-Fraction Pareto Ranker) approach:
+ * vectorized dominance matrix computation with column duplication for
+ * query-type-dependent metric weighting.
+ *
+ * Algorithm:
+ *  1. Prune: per-metric top-K → union of survivors
+ *  2. Build objectives matrix with column duplication for query-type weighting
+ *  3. For each objective column, sort candidates and accumulate pairwise
+ *     dominance counts (duplicate columns contribute via weight multiplier)
+ *  4. Compute fitness: meanDominance × (numDominating + ε) / (numSubmitting + ε)
+ *  5. Sort by fitness, assign ranks
+ *
+ * References:
+ *  - POEM paper: https://iopscience.iop.org/article/10.1088/2632-2153/ab891b
+ *  - TFPR: https://github.com/merckgroup/aidd_tfpr
+ *  - colourdle: https://github.com/aebrer/colourdle
+ */
+import { METRIC_NAMES } from "./types.js";
+const COLUMN_WEIGHTS = {
+    identifier: {
+        bm25: 2,
+        cosine: 1,
+        pathMatch: 1,
+        symbolMatch: 2,
+        importGraph: 1,
+        gitRecency: 1,
+    },
+    natural_language: {
+        bm25: 1,
+        cosine: 2,
+        pathMatch: 1,
+        symbolMatch: 1,
+        importGraph: 1,
+        gitRecency: 1,
+    },
+    path_like: {
+        bm25: 1,
+        cosine: 1,
+        pathMatch: 3,
+        symbolMatch: 1,
+        importGraph: 1,
+        gitRecency: 1,
+    },
+};
+// ============================================================================
+// Fitness smoothing constant (avoids division by zero)
+// ============================================================================
+const EPSILON = 0.05;
+// ============================================================================
+// Pruning
+// ============================================================================
+/**
+ * Per-metric top-K pruning → union of surviving candidate IDs.
+ */
+function pruneTopK(candidates, topK) {
+    if (candidates.size <= topK) {
+        return new Set(candidates.keys());
+    }
+    const union = new Set();
+    for (const metric of METRIC_NAMES) {
+        const pairs = [];
+        for (const [id, scores] of candidates) {
+            pairs.push([id, scores[metric] ?? 0]);
+        }
+        pairs.sort((a, b) => b[1] - a[1]);
+        const limit = Math.min(topK, pairs.length);
+        for (let i = 0; i < limit; i++) {
+            union.add(pairs[i][0]);
+        }
+    }
+    return union;
+}
+// ============================================================================
+// Dominance matrix computation
+// ============================================================================
+/**
+ * Build the dominance count matrix using the TFPR approach.
+ *
+ * For each objective (metric), sorts candidates and accumulates pairwise
+ * dominance: if candidate i ranks above candidate j on an objective,
+ * dominanceCounts[i][j] increases by the column weight.
+ *
+ * Duplicate columns (from column duplication) are handled by multiplying
+ * the contribution by the weight rather than re-sorting — same result,
+ * no redundant work.
+ *
+ * Uses Uint16Array to keep memory compact (max possible value per cell
+ * is the sum of all weights, which is ≤ 10).
+ *
+ * @param scores  Dense array of MetricScores, indexed 0..n-1
+ * @param weights Column weights from query type
+ * @param topK    Only top-K per objective contribute to pairwise dominance
+ * @returns Flat dominance count matrix [n × n] and the total weight sum
+ */
+function buildDominanceCounts(scores, weights, topK) {
+    const n = scores.length;
+    const counts = new Uint16Array(n * n);
+    let totalWeight = 0;
+    // Reusable index array for sorting
+    const indices = new Array(n);
+    for (let i = 0; i < n; i++)
+        indices[i] = i;
+    for (const metric of METRIC_NAMES) {
+        const weight = weights[metric];
+        if (weight === 0)
+            continue;
+        totalWeight += weight;
+        // Sort candidates by this metric (descending)
+        const sorted = indices.slice();
+        sorted.sort((a, b) => (scores[b][metric] ?? 0) - (scores[a][metric] ?? 0));
+        // Only consider top-K for pairwise dominance
+        const k = Math.min(topK, n);
+        // For each pair in the top-K where i ranks above j:
+        // i dominates j on this objective → add weight to counts[i, j]
+        for (let ri = 0; ri < k; ri++) {
+            const i = sorted[ri];
+            const iBase = i * n;
+            for (let rj = ri + 1; rj < k; rj++) {
+                counts[iBase + sorted[rj]] += weight;
+            }
+        }
+    }
+    return [counts, totalWeight];
+}
+/**
+ * Compute fitness scores from the dominance count matrix.
+ *
+ * Fitness = meanDominance × (numDominating + ε) / (numSubmitting + ε)
+ *
+ * Where:
+ *  - meanDominance = average normalized dominance across all other candidates
+ *  - numDominating = count of candidates this one dominates (>50% of objectives)
+ *  - numSubmitting = count of candidates this one fails to dominate (<50%)
+ */
+function computeFitness(counts, n, totalWeight) {
+    const fitness = new Float64Array(n);
+    const threshold = totalWeight * 0.5;
+    for (let i = 0; i < n; i++) {
+        let sumDom = 0;
+        let numDominating = 0;
+        let numSubmitting = 0;
+        const iBase = i * n;
+        for (let j = 0; j < n; j++) {
+            if (i === j)
+                continue;
+            const count = counts[iBase + j];
+            sumDom += count;
+            if (count > threshold)
+                numDominating++;
+            if (count < threshold)
+                numSubmitting++;
+        }
+        const meanDom = n > 1 ? sumDom / ((n - 1) * totalWeight) : 0;
+        fitness[i] = (meanDom * (numDominating + EPSILON)) / (numSubmitting + EPSILON);
+    }
+    return fitness;
+}
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Rank candidates using POEM / TFPR.
+ *
+ * @param candidates Map of candidateId → MetricScores (all values 0–1)
+ * @param queryType  Query type for column duplication weighting
+ * @param topK       Per-metric pruning limit (default: 1000)
+ * @returns Candidates ordered best-first with assigned ranks (0 = best)
+ */
+export function poemRank(candidates, queryType, topK = 1000) {
+    if (candidates.size === 0)
+        return [];
+    // 1. Prune: per-metric top-K → union
+    const surviving = pruneTopK(candidates, topK);
+    // 2. Build dense arrays
+    const ids = [];
+    const scores = [];
+    for (const id of surviving) {
+        const s = candidates.get(id);
+        ids.push(id);
+        scores.push({
+            bm25: s.bm25 ?? 0,
+            cosine: s.cosine ?? 0,
+            pathMatch: s.pathMatch ?? 0,
+            symbolMatch: s.symbolMatch ?? 0,
+            importGraph: s.importGraph ?? 0,
+            gitRecency: s.gitRecency ?? 0,
+        });
+    }
+    const n = ids.length;
+    // Single candidate → rank 0
+    if (n === 1) {
+        return [{ id: ids[0], scores: scores[0], rank: 0 }];
+    }
+    // 3. Compute dominance matrix with column duplication
+    const weights = COLUMN_WEIGHTS[queryType];
+    const [counts, totalWeight] = buildDominanceCounts(scores, weights, topK);
+    // 4. Compute fitness scores
+    const fitness = computeFitness(counts, n, totalWeight);
+    // 5. Sort by fitness (descending) and assign ranks
+    const order = new Array(n);
+    for (let i = 0; i < n; i++)
+        order[i] = i;
+    order.sort((a, b) => fitness[b] - fitness[a]);
+    return order.map((idx, rank) => ({
+        id: ids[idx],
+        scores: scores[idx],
+        rank,
+    }));
+}
+//# sourceMappingURL=poem.js.map