grepmax 0.17.8 → 0.17.9

package/dist/lib/search/searcher.js

@@ -10,12 +10,40 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Searcher = void 0;
+exports.asSymbolQuery = asSymbolQuery;
 exports.buildWhereClause = buildWhereClause;
 const config_1 = require("../../config");
 const filter_builder_1 = require("../utils/filter-builder");
 const pool_1 = require("../workers/pool");
 const intent_1 = require("./intent");
 const pagerank_1 = require("./pagerank");
+// Reads a defined_symbols / referenced_symbols column that may arrive as a plain
+// array or a LanceDB Arrow proxy (.toArray()).
+function readSymbolArray(val) {
+    if (!val)
+        return [];
+    if (Array.isArray(val))
+        return val.filter((v) => typeof v === "string");
+    const maybe = val;
+    if (typeof maybe.toArray === "function") {
+        try {
+            const a = maybe.toArray();
+            return Array.isArray(a) ? a.filter((v) => typeof v === "string") : [];
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    return [];
+}
+// A query that is a single bare identifier ("BeyondError", "requireAuth", "map")
+// is almost always a symbol lookup — the user wants the chunk that *defines*
+// that symbol. Returns the trimmed identifier, or null for natural-language
+// queries. Drives the symbol-definition promotion in search().
+function asSymbolQuery(query) {
+    const q = query.trim();
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(q) ? q : null;
+}
 function buildWhereClause(pathPrefix, filters, searchIntent) {
     var _a;
     const parts = [];
@@ -339,7 +367,7 @@ 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, _k, _l;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
             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
@@ -348,6 +376,8 @@ class Searcher {
             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);
+            // Bare-identifier queries get symbol-definition promotion (see below).
+            const symbolQuery = asSymbolQuery(query);
             const pool = (0, pool_1.getWorkerPool)();
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 const err = new Error("Aborted");
@@ -372,7 +402,7 @@ class Searcher {
             try {
                 table = yield this.db.ensureTable();
             }
-            catch (_m) {
+            catch (_o) {
                 return { data: [] };
             }
             // Ensure FTS index exists (lazy init, retry periodically on failure)
@@ -396,11 +426,14 @@ class Searcher {
             // it in the lightweight path only when the flag is on so we don't bloat the
             // default query path.
             const pagerankEnabled = process.env.GMAX_PAGERANK === "1" && !!pathPrefix;
+            // Symbol-definition promotion needs defined_symbols on every candidate, not
+            // just the final display set — load it for bare-symbol queries too.
+            const needDefinedSymbols = pagerankEnabled || symbolQuery !== null;
             const LIGHTWEIGHT_COLUMNS = [
                 "id", "path", "hash", "chunk_index", "start_line", "end_line",
                 "is_anchor", "chunk_type", "role", "complexity", "is_exported",
                 "content", "parent_symbol", "referenced_symbols", "pooled_colbert_48d",
-                ...(pagerankEnabled ? ["defined_symbols"] : []),
+                ...(needDefinedSymbols ? ["defined_symbols"] : []),
             ];
             // _distance is auto-added by vectorSearch, _score by FTS — include each
             // in the respective query to suppress LanceDB deprecation warnings
@@ -438,7 +471,7 @@ class Searcher {
                             this.ftsAvailable = true;
                             console.warn("[Searcher] Rebuilt FTS index with position support — retry search");
                         }
-                        catch (_o) { }
+                        catch (_p) { }
                     }
                     else {
                         console.warn(`[Searcher] FTS search failed (will retry later): ${msg}`);
@@ -552,6 +585,30 @@ class Searcher {
                 return { data: [] };
             }
             const rerankCandidates = stage2Candidates.slice(0, RERANK_TOP);
+            // Symbol-definition promotion (1/2): membership. For a bare-symbol query,
+            // ensure the chunk(s) that actually DEFINE the symbol reach the rerank set
+            // even when the cosine / RERANK_TOP cuts would drop them — e.g. ErrorCodes
+            // sits at pooled-cosine rank 24 (> RERANK_TOP=20) and resolveActor at fusion
+            // rank 91 (> the stage-2 cut). Pulled from the top-200 fusion pool, bounded
+            // so the rerank batch stays small. Must run before Phase B so the injected
+            // chunks get their colbert data fetched for reranking. The score boost in
+            // (2/2) below then lets them win dedup over their own method-child chunks.
+            if (symbolQuery && rerankCandidates.length > 0) {
+                const present = new Set(rerankCandidates.map((d) => d.id).filter(Boolean));
+                const MAX_INJECT = 5;
+                let injected = 0;
+                for (const d of topCandidates) {
+                    if (injected >= MAX_INJECT)
+                        break;
+                    if (!d.id || present.has(d.id))
+                        continue;
+                    if (readSymbolArray(d.defined_symbols).includes(symbolQuery)) {
+                        rerankCandidates.push(d);
+                        present.add(d.id);
+                        injected++;
+                    }
+                }
+            }
             // Phase B: Lazy-load colbert data only for the ~20 rerank candidates
             if (doRerank && rerankCandidates.length > 0) {
                 const rerankIds = rerankCandidates
@@ -599,13 +656,25 @@ class Searcher {
                     // Small tie-breaker so later items don't all share 0
                     return fusedScore || 1 / (idx + 1);
                 });
+            // Symbol-definition promotion (2/2): score. Multiplicatively boost any
+            // candidate that defines the queried symbol so the definition chunk outranks
+            // its own method-child chunks (e.g. the `BeyondError` class chunk vs its
+            // constructor/toJSON, which otherwise score higher on the literal and evict
+            // the parent in overlap dedup). Multiplicative keeps it scale-invariant
+            // across the rerank-on (ColBERT maxsim) and rerank-off (fusion) score ranges.
+            const envDefBoost = Number.parseFloat((_k = process.env.GMAX_DEF_BOOST) !== null && _k !== void 0 ? _k : "");
+            const DEF_MATCH_BOOST = Number.isFinite(envDefBoost) && envDefBoost >= 1 ? envDefBoost : 5;
             const scored = rerankCandidates.map((doc, idx) => {
                 var _a, _b;
                 const base = (_a = scores === null || scores === void 0 ? void 0 : scores[idx]) !== null && _a !== void 0 ? _a : 0;
                 const key = doc.id || `${doc.path}:${doc.chunk_index}`;
                 const fusedScore = (_b = candidateScores.get(key)) !== null && _b !== void 0 ? _b : 0;
                 const blended = base + FUSED_WEIGHT * fusedScore;
-                const boosted = this.applyStructureBoost(doc, blended, searchIntent);
+                let boosted = this.applyStructureBoost(doc, blended, searchIntent);
+                if (symbolQuery &&
+                    readSymbolArray(doc.defined_symbols).includes(symbolQuery)) {
+                    boosted *= DEF_MATCH_BOOST;
+                }
                 return {
                     record: doc,
                     score: boosted,
@@ -622,7 +691,7 @@ class Searcher {
                 try {
                     const { scores: prScores, max: prMax } = yield (0, pagerank_1.loadOrComputePageRank)(this.db, pathPrefix);
                     if (prMax > 0) {
-                        const envWeight = Number.parseFloat((_k = process.env.GMAX_PR_WEIGHT) !== null && _k !== void 0 ? _k : "");
+                        const envWeight = Number.parseFloat((_l = process.env.GMAX_PR_WEIGHT) !== null && _l !== void 0 ? _l : "");
                         const PR_WEIGHT = Number.isFinite(envWeight) && envWeight >= 0 ? envWeight : 0.05;
                         for (const item of scored) {
                             const raw = item.record.defined_symbols;
@@ -637,7 +706,7 @@ class Searcher {
                                         defs = arr.filter((v) => typeof v === "string");
                                     }
                                 }
-                                catch (_p) { }
+                                catch (_q) { }
                             }
                             const norm = (0, pagerank_1.pageRankBoostForSymbols)(defs, prScores, prMax);
                             item.score += PR_WEIGHT * norm;
@@ -655,7 +724,7 @@ class Searcher {
             // Item 10: Per-file diversification
             const seenFiles = new Map();
             const diversified = [];
-            const envMaxPerFile = Number.parseInt((_l = process.env.GMAX_MAX_PER_FILE) !== null && _l !== void 0 ? _l : "", 10);
+            const envMaxPerFile = Number.parseInt((_m = process.env.GMAX_MAX_PER_FILE) !== null && _m !== void 0 ? _m : "", 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.8",
+  "version": "0.17.9",
   "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.8",
+  "version": "0.17.9",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",