grepmax 0.17.6 → 0.17.7

package/dist/lib/search/searcher.js

@@ -339,13 +339,13 @@ class Searcher {
     }
     search(query, top_k, _search_options, _filters, pathPrefix, intent, signal) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
             const finalLimit = top_k !== null && top_k !== void 0 ? top_k : 10;
             // ColBERT rerank is opt-in as of v0.17.1. On the 97-case eval it
             // regresses MRR@10 by ~3% and doubles query latency; sweep across
             // FUSED_WEIGHT ∈ {0,0.1,0.5,1,2} showed rerank scores dominate
             // fused scores ~30:1 so blend tuning can't recover the loss.
-            const doRerank = (_a = _search_options === null || _search_options === void 0 ? void 0 : _search_options.rerank) !== null && _a !== void 0 ? _a : false;
+            let doRerank = (_a = _search_options === null || _search_options === void 0 ? void 0 : _search_options.rerank) !== null && _a !== void 0 ? _a : false;
             const explain = (_b = _search_options === null || _search_options === void 0 ? void 0 : _search_options.explain) !== null && _b !== void 0 ? _b : false;
             const searchIntent = intent || (0, intent_1.detectIntent)(query);
             const pool = (0, pool_1.getWorkerPool)();
@@ -372,7 +372,7 @@ class Searcher {
             try {
                 table = yield this.db.ensureTable();
             }
-            catch (_k) {
+            catch (_m) {
                 return { data: [] };
             }
             // Ensure FTS index exists (lazy init, retry periodically on failure)
@@ -438,7 +438,7 @@ class Searcher {
                             this.ftsAvailable = true;
                             console.warn("[Searcher] Rebuilt FTS index with position support — retry search");
                         }
-                        catch (_l) { }
+                        catch (_o) { }
                     }
                     else {
                         console.warn(`[Searcher] FTS search failed (will retry later): ${msg}`);
@@ -474,9 +474,46 @@ class Searcher {
             // Free raw search results — docMap holds the only needed references
             vectorResults.length = 0;
             ftsResults.length = 0;
+            // Candidate-concentration gate (Bundle B, v0.17.2 OSS-fixture finding):
+            // ColBERT rerank is shape-sensitive. When the post-fusion pool clusters
+            // into one file (single-file-repo / concentrated shape, e.g. lodash) rerank
+            // lifts recall sharply (+0.283 MRR on the OSS bench); on modular/spread
+            // pools (express, platform) it regresses. So detect the concentrated regime
+            // here and *add* rerank-on for it. This only ever flips doRerank false→true:
+            // an explicit GMAX_RERANK=1 (doRerank already true) is never overridden off.
+            if (!doRerank) {
+                const envConcThreshold = Number.parseFloat((_d = process.env.GMAX_CONCENTRATION_THRESHOLD) !== null && _d !== void 0 ? _d : "");
+                // <= 0 (or NaN with the default) keeps the gate active at 0.7; a value > 1
+                // disables it (no possible share reaches it), giving a rerank-fully-off
+                // baseline for sweeps without touching the doRerank default. 0.7 is the
+                // sweep winner: highest threshold (least spurious firing) that still
+                // retains lodash's +0.15 MRR lift while leaving express/platform flat.
+                const CONCENTRATION_THRESHOLD = Number.isFinite(envConcThreshold) && envConcThreshold > 0
+                    ? envConcThreshold
+                    : 0.7;
+                // Histogram a fixed top-K window (not finalLimit) so the threshold stays
+                // calibrated across callers regardless of the result window they request.
+                const CONCENTRATION_K = 10;
+                const window = fused.slice(0, CONCENTRATION_K);
+                if (window.length > 0 && CONCENTRATION_THRESHOLD <= 1) {
+                    const buckets = new Map();
+                    for (const doc of window) {
+                        buckets.set(doc.path, ((_e = buckets.get(doc.path)) !== null && _e !== void 0 ? _e : 0) + 1);
+                    }
+                    let maxBucket = 0;
+                    for (const count of buckets.values()) {
+                        if (count > maxBucket)
+                            maxBucket = count;
+                    }
+                    const share = maxBucket / window.length;
+                    if (share >= CONCENTRATION_THRESHOLD) {
+                        doRerank = true;
+                    }
+                }
+            }
             // Item 8: Widen PRE_RERANK_K
             // Retrieve a wide set for Stage 1 filtering
-            const envStage1 = Number.parseInt((_d = process.env.GMAX_STAGE1_K) !== null && _d !== void 0 ? _d : "", 10);
+            const envStage1 = Number.parseInt((_f = process.env.GMAX_STAGE1_K) !== null && _f !== void 0 ? _f : "", 10);
             const STAGE1_K = Number.isFinite(envStage1) && envStage1 > 0 ? envStage1 : 200;
             const topCandidates = fused.slice(0, STAGE1_K);
             // Free docMap — topCandidates already holds record references
@@ -484,11 +521,11 @@ class Searcher {
             // Item 9: Two-stage rerank
             // Stage 1: Cheap pooled cosine filter
             let stage2Candidates = topCandidates;
-            const envStage2K = Number.parseInt((_e = process.env.GMAX_STAGE2_K) !== null && _e !== void 0 ? _e : "", 10);
+            const envStage2K = Number.parseInt((_g = process.env.GMAX_STAGE2_K) !== null && _g !== void 0 ? _g : "", 10);
             const STAGE2_K = Number.isFinite(envStage2K) && envStage2K > 0 ? envStage2K : 40;
-            const envRerankTop = Number.parseInt((_f = process.env.GMAX_RERANK_TOP) !== null && _f !== void 0 ? _f : "", 10);
+            const envRerankTop = Number.parseInt((_h = process.env.GMAX_RERANK_TOP) !== null && _h !== void 0 ? _h : "", 10);
             const RERANK_TOP = Number.isFinite(envRerankTop) && envRerankTop > 0 ? envRerankTop : 20;
-            const envBlend = Number.parseFloat((_g = process.env.GMAX_RERANK_BLEND) !== null && _g !== void 0 ? _g : "");
+            const envBlend = Number.parseFloat((_j = process.env.GMAX_RERANK_BLEND) !== null && _j !== void 0 ? _j : "");
             const FUSED_WEIGHT = Number.isFinite(envBlend) && envBlend >= 0 ? envBlend : 0.5;
             if (queryPooled && topCandidates.length > STAGE2_K) {
                 const cosineScores = topCandidates.map((doc) => {
@@ -585,7 +622,7 @@ class Searcher {
                 try {
                     const { scores: prScores, max: prMax } = yield (0, pagerank_1.loadOrComputePageRank)(this.db, pathPrefix);
                     if (prMax > 0) {
-                        const envWeight = Number.parseFloat((_h = process.env.GMAX_PR_WEIGHT) !== null && _h !== void 0 ? _h : "");
+                        const envWeight = Number.parseFloat((_k = process.env.GMAX_PR_WEIGHT) !== null && _k !== void 0 ? _k : "");
                         const PR_WEIGHT = Number.isFinite(envWeight) && envWeight >= 0 ? envWeight : 0.05;
                         for (const item of scored) {
                             const raw = item.record.defined_symbols;
@@ -600,7 +637,7 @@ class Searcher {
                                         defs = arr.filter((v) => typeof v === "string");
                                     }
                                 }
-                                catch (_m) { }
+                                catch (_p) { }
                             }
                             const norm = (0, pagerank_1.pageRankBoostForSymbols)(defs, prScores, prMax);
                             item.score += PR_WEIGHT * norm;
@@ -618,7 +655,7 @@ class Searcher {
             // Item 10: Per-file diversification
             const seenFiles = new Map();
             const diversified = [];
-            const envMaxPerFile = Number.parseInt((_j = process.env.GMAX_MAX_PER_FILE) !== null && _j !== void 0 ? _j : "", 10);
+            const envMaxPerFile = Number.parseInt((_l = process.env.GMAX_MAX_PER_FILE) !== null && _l !== void 0 ? _l : "", 10);
             const MAX_PER_FILE = Number.isFinite(envMaxPerFile) && envMaxPerFile > 0 ? envMaxPerFile : 3;
             for (const item of uniqueScored) {
                 const path = item.record.path || "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.17.6",
+  "version": "0.17.7",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

package/plugins/grepmax/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.17.6",
+  "version": "0.17.7",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",