grepmax 0.17.8 → 0.17.10

package/dist/lib/index/chunker.js

@@ -553,8 +553,78 @@ class TreeSitterChunker {
                             referencedSymbols.push(name);
                         }
                     };
+                    // Leaf identifier node types across grammars (a bare name with no
+                    // named children — `ErrorCodes`, not `a.ErrorCodes`).
+                    const LEAF_ID_TYPES = new Set([
+                        "identifier",
+                        "type_identifier",
+                        "constant", // Ruby
+                        "name", // PHP
+                        "simple_identifier", // Kotlin, Swift
+                        "property_identifier",
+                        "field_identifier", // Go
+                    ]);
+                    const isLeafId = (n) => {
+                        var _a, _b;
+                        return !!n &&
+                            LEAF_ID_TYPES.has(n.type) &&
+                            ((_b = (_a = n.namedChildren) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) === 0;
+                    };
+                    const firstNamed = (n) => { var _a, _b; return (_b = ((_a = n.namedChildren) !== null && _a !== void 0 ? _a : [])[0]) !== null && _b !== void 0 ? _b : null; };
+                    // Resolve the type name out of an instantiation node (`new Foo`,
+                    // `Foo{}`, `new Foo()`), preferring an explicit `type` field and
+                    // falling back to the first named child (qualified names reduce to
+                    // their rightmost segment via simpleRefName).
+                    const instantiatedTypeName = (n) => {
+                        var _a;
+                        const typed = (_a = (n.childForFieldName ? n.childForFieldName("type") : null)) !== null && _a !== void 0 ? _a : firstNamed(n);
+                        if (!typed)
+                            return null;
+                        if (isLeafId(typed))
+                            return typed.text;
+                        return simpleRefName(typed);
+                    };
+                    // First `type_identifier` reachable directly or via a `user_type`
+                    // wrapper — covers Java `instanceof_expression` and Kotlin/Swift
+                    // `check_expression` (`x is T`).
+                    const firstTypeIdent = (n) => {
+                        var _a, _b;
+                        for (const c of (_a = n.namedChildren) !== null && _a !== void 0 ? _a : []) {
+                            if (c.type === "type_identifier")
+                                return c.text;
+                            if (c.type === "user_type") {
+                                const t = ((_b = c.namedChildren) !== null && _b !== void 0 ? _b : []).find((x) => x.type === "type_identifier");
+                                if (t === null || t === void 0 ? void 0 : t.text)
+                                    return t.text;
+                            }
+                        }
+                        return null;
+                    };
+                    // Member / scope access node types, one per grammar. We capture the
+                    // head (object/scope) only when it is a Capitalized leaf identifier,
+                    // so `ErrorCodes.VALIDATION` / `ErrorCodes::NOT_FOUND` yield an edge
+                    // to `ErrorCodes` while `this.x` / `req.body` / lowercase locals do not.
+                    const MEMBER_ACCESS_TYPES = new Set([
+                        "member_expression", // TS/JS
+                        "attribute", // Python
+                        "selector_expression", // Go
+                        "field_access", // Java
+                        "member_access_expression", // C#
+                        "scoped_identifier", // Rust
+                        "scope_resolution", // Ruby
+                        "navigation_expression", // Kotlin, Swift
+                        "field_expression", // Scala
+                        "class_constant_access_expression", // PHP
+                    ]);
+                    // Instantiation node types whose first/`type` child names a type.
+                    const INSTANTIATION_TYPES = new Set([
+                        "object_creation_expression", // Java, C#, PHP
+                        "composite_literal", // Go
+                        "struct_expression", // Rust
+                        "instance_expression", // Scala
+                    ]);
                     const extractRefs = (n) => {
-                        var _a, _b, _c, _d, _e, _f, _g, _h;
+                        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
                         // Handle JS/TS (call_expression), Python (call), Lua (function_call)
                         if (n.type === "call_expression" ||
                             n.type === "call" ||
@@ -617,19 +687,26 @@ class TreeSitterChunker {
                                 }
                             }
                         }
-                        // Identifier-as-value references (TS/JS): edges the call-expression
-                        // capture above misses. These feed the graph-walk consumers (PPR,
+                        // Identifier-as-value references: edges the call-expression capture
+                        // above misses. These feed the graph-walk consumers (PPR,
                         // `gmax dead <ClassName>`, audit) that need class/enum references,
-                        // not just method-call names.
+                        // not just method-call names. Node types are grammar-specific but
+                        // each falls into one of three shapes — instantiation, type-test, or
+                        // member/scope access — handled uniformly across the 14 grammars.
+                        // Shape 1 — instantiation: `new ClassName(...)`, `ClassName{...}`.
                         if (n.type === "new_expression") {
-                            // `new ClassName(...)` — constructor is always a type reference.
+                            // TS/JS — constructor may be qualified (`ns.ClassName`).
                             const ctor = n.childForFieldName
                                 ? n.childForFieldName("constructor")
                                 : null;
                             addRef(simpleRefName(ctor));
                         }
-                        else if (n.type === "binary_expression") {
-                            // `x instanceof ClassName` — the right operand is a type reference.
+                        else if (INSTANTIATION_TYPES.has(n.type)) {
+                            addRef(instantiatedTypeName(n));
+                        }
+                        // Shape 2 — type-test: `x instanceof T`, `x is T`.
+                        if (n.type === "binary_expression") {
+                            // TS/JS, PHP — instanceof is a binary operator.
                             const op = n.childForFieldName
                                 ? n.childForFieldName("operator")
                                 : null;
@@ -640,19 +717,27 @@ class TreeSitterChunker {
                                 addRef(simpleRefName(right));
                             }
                         }
-                        else if (n.type === "member_expression") {
-                            // `ClassName.MEMBER` / `Enum.MEMBER` — capture the object only when
-                            // it looks like a type/namespace (Capitalized identifier), so we
-                            // get `ErrorCodes` from `ErrorCodes.VALIDATION` without flooding
-                            // the graph with `this.x` / `req.body` / lowercase-local access.
-                            const obj = n.childForFieldName
-                                ? n.childForFieldName("object")
-                                : null;
-                            if (obj && obj.type === "identifier" && /^[A-Z]/.test(obj.text)) {
-                                addRef(obj.text);
+                        else if (n.type === "instanceof_expression" || // Java
+                            n.type === "check_expression" // Kotlin, Swift (`x is T`)
+                        ) {
+                            addRef(firstTypeIdent(n));
+                        }
+                        else if (n.type === "is_pattern_expression") {
+                            // C# — `x is BeyondError`: the type sits in a constant_pattern.
+                            const cp = ((_h = n.namedChildren) !== null && _h !== void 0 ? _h : []).find((c) => c.type === "constant_pattern");
+                            const id = cp ? firstNamed(cp) : null;
+                            if (isLeafId(id) && id && /^[A-Z]/.test(id.text))
+                                addRef(id.text);
+                        }
+                        // Shape 3 — member / scope access: `ErrorCodes.MEMBER`,
+                        // `ErrorCodes::MEMBER`. Capitalized head only (skip `this.x`).
+                        if (MEMBER_ACCESS_TYPES.has(n.type)) {
+                            const head = firstNamed(n);
+                            if (head && isLeafId(head) && /^[A-Z]/.test(head.text)) {
+                                addRef(head.text);
                             }
                         }
-                        for (const child of (_h = n.namedChildren) !== null && _h !== void 0 ? _h : []) {
+                        for (const child of (_j = n.namedChildren) !== null && _j !== void 0 ? _j : []) {
                             extractRefs(child);
                         }
                     };

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.10",
   "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.10",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",