grepmax 0.17.1 → 0.17.2

package/dist/commands/dead.js

@@ -0,0 +1,183 @@
+"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.dead = void 0;
+const commander_1 = require("commander");
+const graph_builder_1 = require("../lib/graph/graph-builder");
+const vector_db_1 = require("../lib/store/vector-db");
+const exit_1 = require("../lib/utils/exit");
+const filter_builder_1 = require("../lib/utils/filter-builder");
+const project_registry_1 = require("../lib/utils/project-registry");
+const project_root_1 = require("../lib/utils/project-root");
+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[22m` : s),
+    red: (s) => (useColors ? `\x1b[31m${s}\x1b[39m` : s),
+    yellow: (s) => (useColors ? `\x1b[33m${s}\x1b[39m` : s),
+    green: (s) => (useColors ? `\x1b[32m${s}\x1b[39m` : s),
+};
+const TOP_CALLERS = 3;
+function statusLabel(status) {
+    switch (status) {
+        case "DEAD":
+            return "DEAD";
+        case "PUBLIC_EXPORT":
+            return "PUBLIC EXPORT";
+        case "LIVE":
+            return "LIVE";
+    }
+}
+function formatHuman(r, projectRoot) {
+    const rel = (p) => p.startsWith(projectRoot) ? p.slice(projectRoot.length + 1) : p;
+    const defLoc = `${rel(r.defPath)}:${r.defLine + 1}`;
+    if (r.status === "DEAD") {
+        return `${style.red(style.bold("DEAD"))}  ${defLoc} defines ${style.bold(r.symbol)}`;
+    }
+    if (r.status === "PUBLIC_EXPORT") {
+        return `${style.yellow(style.bold("PUBLIC EXPORT"))}  ${defLoc} defines ${style.bold(r.symbol)} ${style.dim("— no internal callers found; check external usage")}`;
+    }
+    const header = `${style.green(style.bold("LIVE"))}  ${defLoc} defines ${style.bold(r.symbol)} ${style.dim(`— ${r.callerCount} inbound caller${r.callerCount === 1 ? "" : "s"} (top ${Math.min(TOP_CALLERS, r.topCallers.length)}):`)}`;
+    const lines = [header];
+    for (const c of r.topCallers) {
+        lines.push(`  ${rel(c.file)}:${c.line + 1}`);
+    }
+    return lines.join("\n");
+}
+function formatAgent(r, projectRoot) {
+    const rel = (p) => p.startsWith(projectRoot) ? p.slice(projectRoot.length + 1) : p;
+    const defLoc = `${rel(r.defPath)}:${r.defLine + 1}`;
+    const callerLocs = r.topCallers
+        .map((c) => `${rel(c.file)}:${c.line + 1}`)
+        .join(",");
+    return [
+        statusLabel(r.status),
+        defLoc,
+        String(r.callerCount),
+        callerLocs,
+    ].join("\t");
+}
+exports.dead = new commander_1.Command("dead")
+    .description("Report whether a symbol has zero inbound callers in the indexed call graph. " +
+    "The call graph reflects what tree-sitter chunked — dynamic dispatch, " +
+    "reflection, eval, and string-built call sites won't show up, so a 'DEAD' " +
+    "result is a hypothesis, not a proof. Exported public-API symbols " +
+    "legitimately have no in-project callers (reported as PUBLIC EXPORT).")
+    .argument("<symbol>", "The symbol to check")
+    .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("--agent", "Compact TSV output for AI agents", false)
+    .action((symbol, 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 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,
+        });
+        // Resolve the defining chunk to get path, line, and is_exported.
+        const table = yield vectorDb.ensureTable();
+        const defRows = yield table
+            .query()
+            .select(["path", "start_line", "is_exported"])
+            .where(buildScopeWhere(scope, `array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(symbol)}')`))
+            .limit(1)
+            .toArray();
+        if (defRows.length === 0) {
+            console.log(opts.agent ? "(not found)" : `Symbol not found: ${symbol}`);
+            process.exitCode = 1;
+            return;
+        }
+        const defRow = defRows[0];
+        const defPath = String(defRow.path || "");
+        const defLine = Number(defRow.start_line || 0);
+        const isExported = Boolean(defRow.is_exported);
+        const builder = new graph_builder_1.GraphBuilder(vectorDb, scope.pathPrefix, scope.excludePrefixes);
+        const callers = yield builder.getCallers(symbol);
+        const status = callers.length === 0
+            ? isExported
+                ? "PUBLIC_EXPORT"
+                : "DEAD"
+            : "LIVE";
+        const topCallers = callers
+            .slice(0, TOP_CALLERS)
+            .map((c) => ({ file: c.file, line: c.line }));
+        const result = {
+            status,
+            symbol,
+            defPath,
+            defLine,
+            callerCount: callers.length,
+            topCallers,
+        };
+        console.log(opts.agent
+            ? formatAgent(result, projectRoot)
+            : formatHuman(result, projectRoot));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Dead check 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

@@ -161,6 +161,18 @@ const TOOLS = [
             required: ["symbol"],
         },
     },
+    {
+        name: "dead",
+        description: "Report whether a symbol has zero inbound callers in the indexed call graph. Returns DEAD, PUBLIC EXPORT (exported with no internal callers), or LIVE with caller count. Hypothesis, not proof: dynamic dispatch, reflection, and string-built call sites won't show up.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                symbol: { type: "string", description: "Symbol name to check" },
+                root: { type: "string", description: "Project root (absolute path)" },
+            },
+            required: ["symbol"],
+        },
+    },
     {
         name: "list_symbols",
         description: "List indexed symbols with role and export status.",
@@ -1113,6 +1125,57 @@ exports.mcp = new commander_1.Command("mcp")
             }
         });
     }
+    function handleDead(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            ensureWatcher();
+            const symbol = String(args.symbol || "");
+            if (!symbol)
+                return err("Missing required parameter: symbol");
+            try {
+                const root = typeof args.root === "string" && args.root
+                    ? args.root
+                    : projectRoot;
+                const db = getVectorDb();
+                const table = yield db.ensureTable();
+                const prefix = root.endsWith("/") ? root : `${root}/`;
+                const defRows = yield table
+                    .query()
+                    .select(["path", "start_line", "is_exported"])
+                    .where(`array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(symbol)}') AND path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`)
+                    .limit(1)
+                    .toArray();
+                if (defRows.length === 0) {
+                    return ok(`Symbol '${symbol}' not found in the index. Check \`gmax status\` to see which projects are indexed, or try \`gmax search ${symbol}\` to find similar symbols.`);
+                }
+                const defRow = defRows[0];
+                const defPath = String(defRow.path || "");
+                const defLine = Number(defRow.start_line || 0);
+                const isExported = Boolean(defRow.is_exported);
+                const builder = new graph_builder_1.GraphBuilder(db, root);
+                const callers = yield builder.getCallers(symbol);
+                const rel = (p) => p.startsWith(root) ? p.slice(root.length + 1) : p;
+                const defLoc = `${rel(defPath)}:${defLine + 1}`;
+                if (callers.length === 0) {
+                    if (isExported) {
+                        return ok(`PUBLIC EXPORT  ${defLoc} defines ${symbol} — no internal callers found; check external usage`);
+                    }
+                    return ok(`DEAD  ${defLoc} defines ${symbol}`);
+                }
+                const top = callers.slice(0, 3);
+                const lines = [
+                    `LIVE  ${defLoc} defines ${symbol} — ${callers.length} inbound caller${callers.length === 1 ? "" : "s"} (top ${top.length}):`,
+                ];
+                for (const c of top) {
+                    lines.push(`  ${rel(c.file)}:${c.line + 1}`);
+                }
+                return ok(lines.join("\n"));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`Dead check failed: ${msg}`);
+            }
+        });
+    }
     function handleListSymbols(args) {
         return __awaiter(this, void 0, void 0, function* () {
             ensureWatcher();
@@ -1831,6 +1894,9 @@ exports.mcp = new commander_1.Command("mcp")
             case "peek_symbol":
                 result = yield handlePeekSymbol(toolArgs);
                 break;
+            case "dead":
+                result = yield handleDead(toolArgs);
+                break;
             case "list_symbols":
                 result = yield handleListSymbols(toolArgs);
                 break;

package/dist/index.js

@@ -40,6 +40,7 @@ const path = __importStar(require("node:path"));
 const commander_1 = require("commander");
 const add_1 = require("./commands/add");
 const context_1 = require("./commands/context");
+const dead_1 = require("./commands/dead");
 const diff_1 = require("./commands/diff");
 const claude_code_1 = require("./commands/claude-code");
 const codex_1 = require("./commands/codex");
@@ -114,6 +115,7 @@ commander_1.program.addCommand(symbols_1.symbols);
 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(project_1.project);
 commander_1.program.addCommand(related_1.related);
 commander_1.program.addCommand(log_1.log);

package/package.json

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