grepmax 0.17.9 → 0.17.11

package/dist/commands/audit.js

@@ -0,0 +1,314 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.audit = void 0;
+exports.computeAudit = computeAudit;
+const commander_1 = require("commander");
+const arrow_1 = require("../lib/utils/arrow");
+const exit_1 = require("../lib/utils/exit");
+const project_registry_1 = require("../lib/utils/project-registry");
+const project_root_1 = require("../lib/utils/project-root");
+const vector_db_1 = require("../lib/store/vector-db");
+const useColors = process.stdout.isTTY && !process.env.NO_COLOR;
+const style = {
+    bold: (s) => (useColors ? `\x1b[1m${s}\x1b[22m` : s),
+    dim: (s) => (useColors ? `\x1b[2m${s}\x1b[39m` : s),
+    red: (s) => (useColors ? `\x1b[31m${s}\x1b[39m` : s),
+    yellow: (s) => (useColors ? `\x1b[33m${s}\x1b[39m` : s),
+    cyan: (s) => (useColors ? `\x1b[36m${s}\x1b[39m` : s),
+};
+// Names too generic to be useful as god-node signal (`id`, `el`, `fn`, …).
+const MIN_GOD_NAME_LEN = 3;
+function rel(p, prefix) {
+    return p.startsWith(prefix) ? p.slice(prefix.length) : p;
+}
+/**
+ * Pure aggregation over chunk rows — no DB, no I/O. Builds the symbol→def map,
+ * cross-file inbound edges, and per-file fan-in/out, then derives god nodes
+ * (most depended-upon symbols), hub files (most depended-upon files), and
+ * dead-code candidates (non-exported symbols with zero inbound references).
+ * `top` caps each list; `deadTotal` reports the full pre-cap dead count.
+ */
+function computeAudit(rows, prefix, top) {
+    // First definition of a symbol wins (matches GraphBuilder semantics).
+    const defs = new Map();
+    // Distinct files that reference a symbol (cross-file inbound edges).
+    const inboundFiles = new Map();
+    const inboundTotal = new Map();
+    // Per-file aggregates.
+    const fileDefs = new Map();
+    const fileOutRefs = new Map();
+    const files = new Set();
+    for (const row of rows) {
+        const file = String(row.path || "");
+        const line = Number(row.start_line || 0);
+        const exported = Boolean(row.is_exported);
+        const defSyms = (0, arrow_1.toArr)(row.defined_symbols);
+        const refSyms = (0, arrow_1.toArr)(row.referenced_symbols);
+        files.add(file);
+        for (const s of defSyms) {
+            if (!defs.has(s)) {
+                defs.set(s, { file, line, exported, complexity: 0 });
+            }
+            if (!fileDefs.has(file))
+                fileDefs.set(file, new Set());
+            fileDefs.get(file).add(s);
+        }
+        for (const s of refSyms) {
+            if (!inboundFiles.has(s))
+                inboundFiles.set(s, new Set());
+            inboundFiles.get(s).add(file);
+            inboundTotal.set(s, (inboundTotal.get(s) || 0) + 1);
+            if (!fileOutRefs.has(file))
+                fileOutRefs.set(file, new Set());
+            fileOutRefs.get(file).add(s);
+        }
+    }
+    // God nodes — in-project symbols by distinct external inbound files.
+    const godNodes = [];
+    for (const [symbol, info] of defs) {
+        if (symbol.length < MIN_GOD_NAME_LEN)
+            continue;
+        const refFiles = inboundFiles.get(symbol);
+        if (!refFiles)
+            continue;
+        let external = 0;
+        for (const f of refFiles)
+            if (f !== info.file)
+                external++;
+        if (external === 0)
+            continue;
+        godNodes.push({
+            symbol,
+            file: rel(info.file, prefix),
+            line: info.line,
+            inboundFiles: external,
+            totalRefs: inboundTotal.get(symbol) || 0,
+        });
+    }
+    godNodes.sort((a, b) => b.inboundFiles - a.inboundFiles || b.totalRefs - a.totalRefs);
+    // Hub files — distinct external files depending on each file (a file G
+    // depends on F if G references any symbol F defines).
+    const hubFiles = [];
+    for (const [file, syms] of fileDefs) {
+        const dependents = new Set();
+        for (const s of syms) {
+            const refFiles = inboundFiles.get(s);
+            if (!refFiles)
+                continue;
+            for (const f of refFiles)
+                if (f !== file)
+                    dependents.add(f);
+        }
+        // Fan-out: distinct referenced symbols that are defined somewhere
+        // in-project (external-library calls don't count as coupling).
+        let fanOut = 0;
+        const out = fileOutRefs.get(file);
+        if (out)
+            for (const s of out)
+                if (defs.has(s))
+                    fanOut++;
+        hubFiles.push({
+            file: rel(file, prefix),
+            dependents: dependents.size,
+            defines: syms.size,
+            fanOut,
+        });
+    }
+    hubFiles.sort((a, b) => b.dependents - a.dependents || b.defines - a.defines);
+    // Dead candidates — non-exported in-project symbols with zero inbound
+    // references anywhere (including their own file).
+    const deadAll = [];
+    for (const [symbol, info] of defs) {
+        if (info.exported)
+            continue;
+        if ((inboundTotal.get(symbol) || 0) > 0)
+            continue;
+        deadAll.push({ symbol, file: rel(info.file, prefix), line: info.line });
+    }
+    deadAll.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+    return {
+        scannedChunks: rows.length,
+        scannedFiles: files.size,
+        godNodes: godNodes.slice(0, top),
+        hubFiles: hubFiles.filter((h) => h.dependents > 0).slice(0, top),
+        deadCandidates: deadAll.slice(0, top),
+        deadTotal: deadAll.length,
+    };
+}
+function formatHuman(r) {
+    const out = [];
+    out.push(`${style.bold("Audit")} ${style.dim(`— ${r.scannedChunks} chunks across ${r.scannedFiles} files`)}`);
+    out.push("");
+    out.push(style.bold("God nodes") + style.dim(" (most depended-upon symbols)"));
+    if (r.godNodes.length === 0) {
+        out.push(style.dim("  none"));
+    }
+    else {
+        for (const g of r.godNodes) {
+            out.push(`  ${style.cyan(g.symbol.padEnd(28))} ${style.dim(`${g.inboundFiles} files`)}, ${g.totalRefs} refs  ${style.dim(`${g.file}:${g.line + 1}`)}`);
+        }
+    }
+    out.push("");
+    out.push(style.bold("Hub files") + style.dim(" (most depended-upon files)"));
+    if (r.hubFiles.length === 0) {
+        out.push(style.dim("  none"));
+    }
+    else {
+        for (const h of r.hubFiles) {
+            out.push(`  ${h.file.padEnd(44)} ${style.dim(`${h.dependents} dependents, ${h.defines} defs, fan-out ${h.fanOut}`)}`);
+        }
+    }
+    out.push("");
+    out.push(style.bold("Dead-code candidates") +
+        style.dim(` (${r.deadTotal} non-exported symbols with zero inbound refs)`));
+    if (r.deadCandidates.length === 0) {
+        out.push(style.dim("  none"));
+    }
+    else {
+        for (const d of r.deadCandidates) {
+            out.push(`  ${style.red(d.symbol.padEnd(28))} ${style.dim(`${d.file}:${d.line + 1}`)}`);
+        }
+        if (r.deadTotal > r.deadCandidates.length) {
+            out.push(style.dim(`  … and ${r.deadTotal - r.deadCandidates.length} more`));
+        }
+    }
+    out.push("");
+    out.push(style.dim("Static call graph: dynamic dispatch, reflection, eval, and string-built " +
+        "call sites are invisible. Dead candidates are hypotheses — verify with " +
+        "`gmax dead <symbol>` and `grep` before removing."));
+    return out.join("\n");
+}
+function formatAgent(r) {
+    const lines = [];
+    lines.push(`scanned\t${r.scannedChunks}\t${r.scannedFiles}`);
+    for (const g of r.godNodes) {
+        lines.push(`god\t${g.symbol}\t${g.file}:${g.line + 1}\t${g.inboundFiles}\t${g.totalRefs}`);
+    }
+    for (const h of r.hubFiles) {
+        lines.push(`hub\t${h.file}\t${h.dependents}\t${h.defines}\t${h.fanOut}`);
+    }
+    for (const d of r.deadCandidates) {
+        lines.push(`dead\t${d.symbol}\t${d.file}:${d.line + 1}`);
+    }
+    lines.push(`dead_total\t${r.deadTotal}`);
+    return lines.join("\n");
+}
+exports.audit = new commander_1.Command("audit")
+    .description("Graph-summary of the indexed project — god nodes (most depended-upon " +
+    "symbols), hub files (most depended-upon files), and dead-code candidates " +
+    "(non-exported symbols with zero inbound references). One pass over the " +
+    "static call graph; dynamic dispatch / reflection / eval are invisible, so " +
+    "dead candidates are hypotheses, not proof.")
+    .option("--root <dir>", "Project root directory")
+    .option("--in <subpath>", "Restrict to a sub-path of the project (repeatable)", (value, prev) => prev ? [...prev, value] : [value])
+    .option("--exclude <subpath>", "Exclude a sub-path of the project (repeatable)", (value, prev) => prev ? [...prev, value] : [value])
+    .option("--top <n>", "How many of each category to show", "10")
+    .option("--agent", "Compact TSV output for AI agents", false)
+    .action((opts) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const root = (0, project_registry_1.resolveRootOrExit)(opts.root);
+    if (root === null)
+        return;
+    let vectorDb = null;
+    try {
+        const projectRoot = (_a = (0, project_root_1.findProjectRoot)(root)) !== null && _a !== void 0 ? _a : root;
+        const prefix = projectRoot.endsWith("/")
+            ? projectRoot
+            : `${projectRoot}/`;
+        const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+        vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+        const { resolveScope, buildScopeWhere } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/scope-filter")));
+        const scope = resolveScope({
+            projectRoot,
+            in: opts.in,
+            exclude: opts.exclude,
+        });
+        const top = Math.max(1, Number.parseInt(opts.top, 10) || 10);
+        const table = yield vectorDb.ensureTable();
+        const rows = yield table
+            .query()
+            .select([
+            "path",
+            "start_line",
+            "defined_symbols",
+            "referenced_symbols",
+            "is_exported",
+        ])
+            .where(buildScopeWhere(scope))
+            .limit(500000)
+            .toArray();
+        if (rows.length === 0) {
+            console.log(opts.agent
+                ? "(no indexed data)"
+                : `No indexed data for ${projectRoot}. Run: gmax index --path ${projectRoot}`);
+            process.exitCode = 1;
+            return;
+        }
+        const result = computeAudit(rows.map((r) => ({
+            path: String(r.path || ""),
+            start_line: Number(r.start_line || 0),
+            is_exported: Boolean(r.is_exported),
+            defined_symbols: (0, arrow_1.toArr)(r.defined_symbols),
+            referenced_symbols: (0, arrow_1.toArr)(r.referenced_symbols),
+        })), prefix, top);
+        console.log(opts.agent ? formatAgent(result) : formatHuman(result));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Audit failed:", message);
+        process.exitCode = 1;
+    }
+    finally {
+        if (vectorDb) {
+            try {
+                yield vectorDb.close();
+            }
+            catch (err) {
+                console.error("Failed to close VectorDB:", err);
+            }
+        }
+        yield (0, exit_1.gracefulExit)();
+    }
+}));

package/dist/commands/mcp.js

@@ -62,6 +62,7 @@ const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const commander_1 = require("commander");
 const config_1 = require("../config");
+const audit_1 = require("./audit");
 const graph_builder_1 = require("../lib/graph/graph-builder");
 const index_config_1 = require("../lib/index/index-config");
 const syncer_1 = require("../lib/index/syncer");
@@ -239,6 +240,23 @@ const TOOLS = [
             required: ["symbol"],
         },
     },
+    {
+        name: "audit",
+        description: "Graph-summary of the indexed project in one call: god nodes (most depended-upon symbols), hub files (most depended-upon files), and dead-code candidates (non-exported symbols with zero inbound references). Built from the static call graph — dynamic dispatch, reflection, eval, and type-position-only references are invisible, so dead candidates are hypotheses; verify with the `dead` tool before acting.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                root: {
+                    type: "string",
+                    description: "Project root (default: current)",
+                },
+                top: {
+                    type: "number",
+                    description: "How many of each category to return (default 10)",
+                },
+            },
+        },
+    },
     {
         name: "list_symbols",
         description: "List indexed symbols with role and export status.",
@@ -1338,6 +1356,75 @@ exports.mcp = new commander_1.Command("mcp")
             }
         });
     }
+    function handleAudit(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            ensureWatcher();
+            const root = typeof args.root === "string" && args.root
+                ? path.resolve(args.root)
+                : projectRoot;
+            const prefix = root.endsWith("/") ? root : `${root}/`;
+            const top = Math.min(Math.max(Number(args.top) || 10, 1), 50);
+            try {
+                const db = getVectorDb();
+                const table = yield db.ensureTable();
+                const rows = yield table
+                    .query()
+                    .select([
+                    "path",
+                    "start_line",
+                    "defined_symbols",
+                    "referenced_symbols",
+                    "is_exported",
+                ])
+                    .where(`path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`)
+                    .limit(500000)
+                    .toArray();
+                if (rows.length === 0) {
+                    return ok(`No indexed data found for ${root}. Run: gmax index --path ${root}`);
+                }
+                const audit = (0, audit_1.computeAudit)(rows.map((r) => ({
+                    path: String(r.path || ""),
+                    start_line: Number(r.start_line || 0),
+                    is_exported: Boolean(r.is_exported),
+                    defined_symbols: toStringArray(r.defined_symbols),
+                    referenced_symbols: toStringArray(r.referenced_symbols),
+                })), prefix, top);
+                const lines = [];
+                lines.push(`Audit — ${audit.scannedChunks} chunks across ${audit.scannedFiles} files`);
+                lines.push("");
+                lines.push("God nodes (most depended-upon symbols):");
+                for (const g of audit.godNodes) {
+                    lines.push(`  ${g.symbol} — ${g.inboundFiles} files, ${g.totalRefs} refs (${g.file}:${g.line + 1})`);
+                }
+                if (audit.godNodes.length === 0)
+                    lines.push("  none");
+                lines.push("");
+                lines.push("Hub files (most depended-upon files):");
+                for (const h of audit.hubFiles) {
+                    lines.push(`  ${h.file} — ${h.dependents} dependents, ${h.defines} defs, fan-out ${h.fanOut}`);
+                }
+                if (audit.hubFiles.length === 0)
+                    lines.push("  none");
+                lines.push("");
+                lines.push(`Dead-code candidates (${audit.deadTotal} non-exported symbols with zero inbound refs):`);
+                for (const d of audit.deadCandidates) {
+                    lines.push(`  ${d.symbol} (${d.file}:${d.line + 1})`);
+                }
+                if (audit.deadCandidates.length === 0)
+                    lines.push("  none");
+                if (audit.deadTotal > audit.deadCandidates.length) {
+                    lines.push(`  … and ${audit.deadTotal - audit.deadCandidates.length} more`);
+                }
+                lines.push("");
+                lines.push("Static call graph: dynamic dispatch, reflection, eval, and type-position-only references are invisible. Dead candidates are hypotheses — verify with the `dead` tool before removing.");
+                return ok(lines.join("\n"));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`Audit failed: ${msg}`);
+            }
+        });
+    }
     function handleListSymbols(args) {
         return __awaiter(this, void 0, void 0, function* () {
             ensureWatcher();
@@ -2080,6 +2167,9 @@ exports.mcp = new commander_1.Command("mcp")
             case "dead":
                 result = yield handleDead(toolArgs);
                 break;
+            case "audit":
+                result = yield handleAudit(toolArgs);
+                break;
             case "list_symbols":
                 result = yield handleListSymbols(toolArgs);
                 break;

package/dist/index.js

@@ -39,6 +39,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const commander_1 = require("commander");
 const add_1 = require("./commands/add");
+const audit_1 = require("./commands/audit");
 const context_1 = require("./commands/context");
 const dead_1 = require("./commands/dead");
 const diff_1 = require("./commands/diff");
@@ -116,6 +117,7 @@ commander_1.program.addCommand(trace_1.trace);
 commander_1.program.addCommand(extract_1.extract);
 commander_1.program.addCommand(peek_1.peek);
 commander_1.program.addCommand(dead_1.dead);
+commander_1.program.addCommand(audit_1.audit);
 commander_1.program.addCommand(project_1.project);
 commander_1.program.addCommand(related_1.related);
 commander_1.program.addCommand(log_1.log);

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.17.9",
+  "version": "0.17.11",
   "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.9",
+  "version": "0.17.11",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",