grepmax 0.23.0 → 0.24.0

package/dist/lib/graph/impact-rollup.js

@@ -0,0 +1,202 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeToProject = relativeToProject;
+exports.impactPackageBucket = impactPackageBucket;
+exports.buildImpactRollup = buildImpactRollup;
+exports.formatImpactRollupHuman = formatImpactRollupHuman;
+exports.formatImpactRollupAgent = formatImpactRollupAgent;
+const path = __importStar(require("node:path"));
+const impact_1 = require("./impact");
+const test_hits_1 = require("./test-hits");
+function relativeToProject(projectRoot, filePath) {
+    return filePath.startsWith(`${projectRoot}/`)
+        ? filePath.slice(projectRoot.length + 1)
+        : filePath;
+}
+function impactPackageBucket(projectRoot, filePath) {
+    const rel = relativeToProject(projectRoot, filePath).replace(/\\/g, "/");
+    const parts = rel.split("/").filter(Boolean);
+    if (parts[0] === "packages" && parts[1])
+        return `packages/${parts[1]}`;
+    if (parts[0])
+        return parts[0];
+    return path.basename(filePath) || ".";
+}
+function sortDetailedDependents(dependents) {
+    return [...dependents].sort((a, b) => b.sharedSymbols - a.sharedSymbols || a.file.localeCompare(b.file));
+}
+function buildImpactRollup(opts) {
+    var _a, _b, _c;
+    const top = Math.max(1, (_a = opts.top) !== null && _a !== void 0 ? _a : 10);
+    const productionDependents = sortDetailedDependents(opts.dependents.filter((d) => !(0, impact_1.isTestPath)(d.file)));
+    const tests = (0, test_hits_1.groupTestHitsByFile)((_b = opts.tests) !== null && _b !== void 0 ? _b : []);
+    const exports = opts.targetSymbols
+        .map((symbol) => {
+        const matches = productionDependents.filter((d) => d.symbols.includes(symbol));
+        return {
+            symbol,
+            dependentCount: matches.length,
+            topDependents: matches.slice(0, top),
+        };
+    })
+        .sort((a, b) => b.dependentCount - a.dependentCount || a.symbol.localeCompare(b.symbol));
+    const byPackage = new Map();
+    for (const dep of productionDependents) {
+        const bucket = impactPackageBucket(opts.projectRoot, dep.file);
+        const entry = (_c = byPackage.get(bucket)) !== null && _c !== void 0 ? _c : {
+            dependents: [],
+            symbols: new Set(),
+        };
+        entry.dependents.push(dep);
+        for (const sym of dep.symbols)
+            entry.symbols.add(sym);
+        byPackage.set(bucket, entry);
+    }
+    const packages = [...byPackage.entries()]
+        .map(([name, entry]) => ({
+        name,
+        dependentCount: entry.dependents.length,
+        symbols: [...entry.symbols].sort(),
+        topDependents: sortDetailedDependents(entry.dependents).slice(0, top),
+    }))
+        .sort((a, b) => b.dependentCount - a.dependentCount || a.name.localeCompare(b.name));
+    return {
+        targetSymbols: [...opts.targetSymbols],
+        productionDependents,
+        packages,
+        exports,
+        tests,
+        topDependents: productionDependents.slice(0, top),
+        topTests: tests.slice(0, top),
+    };
+}
+function symbolsLabel(symbols) {
+    if (symbols.length <= 3)
+        return symbols.join(",");
+    return `${symbols.slice(0, 3).join(",")}(+${symbols.length - 3})`;
+}
+function formatImpactRollupHuman(rollup, opts) {
+    const lines = [`Impact rollup for ${opts.target}:`, ""];
+    lines.push("Summary:");
+    lines.push(`  Exports: ${rollup.targetSymbols.length}`);
+    lines.push(`  Production dependents: ${rollup.productionDependents.length}`);
+    lines.push(`  Packages: ${rollup.packages.length}`);
+    if (opts.includeTests)
+        lines.push(`  Affected tests: ${rollup.tests.length}`);
+    lines.push("", `Exports (${rollup.exports.length}):`);
+    for (const ex of rollup.exports) {
+        lines.push(`  ${ex.symbol}  ${ex.dependentCount} dependent${ex.dependentCount === 1 ? "" : "s"}`);
+        for (const dep of ex.topDependents) {
+            lines.push(`    ${relativeToProject(opts.projectRoot, dep.file)}`);
+        }
+    }
+    lines.push("", `Packages (${rollup.packages.length}):`);
+    if (rollup.packages.length === 0) {
+        lines.push("  none");
+    }
+    else {
+        for (const pkg of rollup.packages) {
+            lines.push(`  ${pkg.name}  ${pkg.dependentCount} file${pkg.dependentCount === 1 ? "" : "s"}  symbols:${symbolsLabel(pkg.symbols)}`);
+            for (const dep of pkg.topDependents) {
+                lines.push(`    ${relativeToProject(opts.projectRoot, dep.file)} (${symbolsLabel(dep.symbols)})`);
+            }
+        }
+    }
+    lines.push("", `Top dependents (${rollup.topDependents.length}):`);
+    if (rollup.topDependents.length === 0) {
+        lines.push("  none");
+    }
+    else {
+        for (const dep of rollup.topDependents) {
+            lines.push(`  ${relativeToProject(opts.projectRoot, dep.file)} (${symbolsLabel(dep.symbols)})`);
+        }
+    }
+    if (opts.includeTests) {
+        lines.push("", `Affected tests (${rollup.tests.length}):`);
+        if (rollup.topTests.length === 0) {
+            lines.push("  none");
+        }
+        else {
+            for (const test of rollup.topTests) {
+                lines.push(`  ${relativeToProject(opts.projectRoot, test.file)}:${test.line + 1}  (${(0, test_hits_1.hopLabelHuman)(test.hops)}${(0, test_hits_1.formatViaHuman)(test.via)})`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+function formatImpactRollupAgent(rollup, opts) {
+    const lines = [
+        [
+            "summary",
+            `target=${opts.target}`,
+            `exports=${rollup.targetSymbols.length}`,
+            `deps=${rollup.productionDependents.length}`,
+            `packages=${rollup.packages.length}`,
+            `tests=${opts.includeTests ? rollup.tests.length : "skipped"}`,
+        ].join("\t"),
+    ];
+    for (const ex of rollup.exports) {
+        lines.push(["export", ex.symbol, `deps=${ex.dependentCount}`].join("\t"));
+    }
+    for (const pkg of rollup.packages) {
+        lines.push([
+            "pkg",
+            pkg.name,
+            `deps=${pkg.dependentCount}`,
+            `symbols=${symbolsLabel(pkg.symbols)}`,
+        ].join("\t"));
+    }
+    for (const dep of rollup.topDependents) {
+        lines.push([
+            "dep",
+            relativeToProject(opts.projectRoot, dep.file),
+            `symbols=${symbolsLabel(dep.symbols)}`,
+        ].join("\t"));
+    }
+    if (opts.includeTests) {
+        for (const test of rollup.topTests) {
+            lines.push([
+                "test",
+                `${relativeToProject(opts.projectRoot, test.file)}:${test.line + 1}`,
+                (0, test_hits_1.hopLabelAgent)(test.hops),
+                (0, test_hits_1.formatViaAgent)(test.via).trim(),
+            ]
+                .filter(Boolean)
+                .join("\t"));
+        }
+    }
+    return lines.join("\n");
+}

package/dist/lib/graph/impact.js

@@ -13,6 +13,7 @@ exports.isTestPath = isTestPath;
 exports.resolveTargetSymbols = resolveTargetSymbols;
 exports.findTests = findTests;
 exports.findDependents = findDependents;
+exports.findDependentsDetailed = findDependentsDetailed;
 const languages_1 = require("../core/languages");
 const filter_builder_1 = require("../utils/filter-builder");
 const query_timeout_1 = require("../utils/query-timeout");
@@ -244,6 +245,15 @@ function walkCallers(symbol, graphBuilder, testHits, currentHop, maxDepth, visit
  * Returns files sorted by number of shared symbols (descending).
  */
 function findDependents(symbols_1, vectorDb_1, projectRoot_1, excludePaths_1) {
+    return __awaiter(this, arguments, void 0, function* (symbols, vectorDb, projectRoot, excludePaths, limit = 10, excludePrefixes, symbolFamilies) {
+        return (yield findDependentsDetailed(symbols, vectorDb, projectRoot, excludePaths, limit, excludePrefixes, symbolFamilies)).map(({ file, sharedSymbols }) => ({ file, sharedSymbols }));
+    });
+}
+/**
+ * Find dependent files and retain which target symbols each file matched.
+ * The legacy `findDependents` projects this down to `{file, sharedSymbols}`.
+ */
+function findDependentsDetailed(symbols_1, vectorDb_1, projectRoot_1, excludePaths_1) {
     return __awaiter(this, arguments, void 0, function* (symbols, vectorDb, projectRoot, excludePaths, limit = 10, excludePrefixes, symbolFamilies) {
         var _a, _b;
         const table = yield vectorDb.ensureTable();
@@ -279,6 +289,10 @@ function findDependents(symbols_1, vectorDb_1, projectRoot_1, excludePaths_1) {
         return Array.from(symbolsByFile.entries())
             .sort((a, b) => b[1].size - a[1].size)
             .slice(0, limit)
-            .map(([file, symbols]) => ({ file, sharedSymbols: symbols.size }));
+            .map(([file, symbols]) => ({
+            file,
+            sharedSymbols: symbols.size,
+            symbols: [...symbols].sort(),
+        }));
     });
 }

package/dist/lib/help/agent-cheatsheet.js

@@ -31,6 +31,7 @@ Understand:
 Survey:
   gmax project                       codebase overview (langs, structure, key symbols)
   gmax skeleton <file>               file structure (file path, NOT a directory)
+  gmax surprises --experimental      similar but graph-disconnected file pairs
   gmax context "topic-or-path" --budget 4000 topic summary or deterministic file/dir context
   gmax log <path-or-symbol>          git commits (replaces recent/diff)
   gmax status                        indexed projects

package/dist/lib/skeleton/skeletonizer.js

@@ -69,6 +69,8 @@ const DEFAULT_OPTIONS = {
     includeSummary: true,
     maxCallsInSummary: 4,
 };
+const SQL_TEMPLATE_LANGS = new Set(["typescript", "tsx", "javascript"]);
+const SQL_IDENTIFIER_PATTERN = '(?:"[^"]+"|\\[[^\\]]+\\]|`[^`]+`|[A-Za-z_][\\w$]*)(?:\\s*\\.\\s*(?:"[^"]+"|\\[[^\\]]+\\]|`[^`]+`|[A-Za-z_][\\w$]*)){0,2}';
 // WASM locator (same as chunker.ts)
 function resolveTreeSitterWasmLocator() {
     try {
@@ -238,10 +240,12 @@ class Skeletonizer {
         }
         // Extract metadata from the body
         const referencedSymbols = this.extractReferencedSymbols(bodyNode);
+        const sqlTemplates = this.extractSqlTemplateSummaries(bodyNode, langId);
         const complexity = this.calculateComplexity(bodyNode);
         const role = this.classifyRole(complexity, referencedSymbols.length);
         const metadata = {
             referencedSymbols,
+            sqlTemplates,
             complexity,
             role,
         };
@@ -450,6 +454,120 @@ class Skeletonizer {
         extract(node);
         return refs;
     }
+    /**
+     * Surface SQL tagged templates hidden inside elided JS/TS function bodies.
+     * This is intentionally a lightweight skeleton hint, not a SQL parser.
+     */
+    extractSqlTemplateSummaries(node, langId) {
+        if (!SQL_TEMPLATE_LANGS.has(langId))
+            return [];
+        const summaries = [];
+        const seen = new Set();
+        const extract = (n) => {
+            const template = (n.namedChildren || []).find((child) => child.type === "template_string");
+            if (template && this.isSqlTaggedTemplate(n, template)) {
+                const summary = this.summarizeSqlTemplate(template);
+                if (summary && !seen.has(summary)) {
+                    seen.add(summary);
+                    summaries.push(summary);
+                }
+                return;
+            }
+            for (const child of n.namedChildren || []) {
+                extract(child);
+            }
+        };
+        extract(node);
+        return summaries;
+    }
+    isSqlTaggedTemplate(node, template) {
+        const tagText = node.text
+            .slice(0, template.startIndex - node.startIndex)
+            .trim();
+        return /(?:^|[.\s])sql(?:$|[.<(])/.test(tagText);
+    }
+    summarizeSqlTemplate(template) {
+        var _a;
+        const sqlText = this.extractTemplateText(template)
+            .replace(/--[^\n]*/g, " ")
+            .replace(/\/\*[\s\S]*?\*\//g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        if (!sqlText)
+            return null;
+        const op = (_a = sqlText.match(/\b(select|insert|update|delete|merge|create|alter|drop|truncate)\b/i)) === null || _a === void 0 ? void 0 : _a[1];
+        if (!op)
+            return "SQL";
+        const operation = op.toUpperCase();
+        const tables = this.extractSqlTables(sqlText, operation);
+        if (tables.length === 0)
+            return operation;
+        const tableList = tables.slice(0, 2);
+        if (tables.length > tableList.length)
+            tableList.push("...");
+        return `${operation} ${tableList.join(", ")}`;
+    }
+    extractTemplateText(template) {
+        const parts = [];
+        for (const child of template.namedChildren || []) {
+            if (child.type === "string_fragment") {
+                parts.push(child.text);
+            }
+            else if (child.type === "template_substitution") {
+                parts.push(" ? ");
+            }
+        }
+        if (parts.length > 0)
+            return parts.join("");
+        return template.text.slice(1, -1).replace(/\$\{[^}]*\}/g, " ? ");
+    }
+    extractSqlTables(sqlText, operation) {
+        const tables = [];
+        const seen = new Set();
+        const addMatches = (pattern) => {
+            for (const match of sqlText.matchAll(pattern)) {
+                const table = this.normalizeSqlIdentifier(match[1]);
+                if (table && !seen.has(table)) {
+                    seen.add(table);
+                    tables.push(table);
+                }
+            }
+        };
+        switch (operation) {
+            case "SELECT":
+                addMatches(new RegExp(`\\b(?:from|join)\\s+(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "INSERT":
+                addMatches(new RegExp(`\\binsert\\s+into\\s+(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "UPDATE":
+                addMatches(new RegExp(`\\bupdate\\s+(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "DELETE":
+                addMatches(new RegExp(`\\bdelete\\s+from\\s+(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "MERGE":
+                addMatches(new RegExp(`\\bmerge\\s+into\\s+(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "CREATE":
+                addMatches(new RegExp(`\\bcreate\\s+(?:or\\s+replace\\s+)?(?:table|view|materialized\\s+view|index)\\s+(?:if\\s+not\\s+exists\\s+)?(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "ALTER":
+            case "DROP":
+                addMatches(new RegExp(`\\b${operation.toLowerCase()}\\s+(?:table|view|materialized\\s+view|index)\\s+(?:if\\s+(?:exists|not\\s+exists)\\s+)?(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "TRUNCATE":
+                addMatches(new RegExp(`\\btruncate\\s+(?:table\\s+)?(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+        }
+        return tables;
+    }
+    normalizeSqlIdentifier(identifier) {
+        const normalized = identifier === null || identifier === void 0 ? void 0 : identifier.replace(/\s*\.\s*/g, ".").replace(/["`[\]]/g, "").trim();
+        if (!normalized || normalized === "?")
+            return null;
+        return normalized;
+    }
     /**
      * Calculate cyclomatic complexity of a node.
      */

package/dist/lib/skeleton/summary-formatter.js

@@ -25,7 +25,7 @@ const DEFAULT_OPTIONS = {
  * // Output: "// → findByEmail, compare, sign | C:8 | ORCH"
  */
 function formatSummary(metadata, options = {}) {
-    var _a;
+    var _a, _b;
     const opts = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
     const parts = [];
     // Calls (referenced symbols)
@@ -36,6 +36,13 @@ function formatSummary(metadata, options = {}) {
         }
         parts.push(`→ ${calls.join(", ")}`);
     }
+    if ((_b = metadata.sqlTemplates) === null || _b === void 0 ? void 0 : _b.length) {
+        const templates = metadata.sqlTemplates.slice(0, 3);
+        if (metadata.sqlTemplates.length > templates.length) {
+            templates.push("...");
+        }
+        parts.push(`SQL: ${templates.join("; ")}`);
+    }
     // Complexity (only if > 1, trivial functions don't need it)
     if (opts.showComplexity && metadata.complexity && metadata.complexity > 1) {
         parts.push(`C:${metadata.complexity}`);

package/dist/lib/workers/pool.js

@@ -160,7 +160,10 @@ function resolveProcessWorker() {
         return { filename: jsWorker, execArgv: [] };
     }
     if (fs.existsSync(tsWorker)) {
-        return { filename: tsWorker, execArgv: ["-r", "ts-node/register"] };
+        return {
+            filename: tsWorker,
+            execArgv: ["--import", require.resolve("tsx")],
+        };
     }
     throw new Error("Process worker file not found");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -31,6 +31,8 @@
     "bench:oss:json": "GMAX_EVAL_JSON=1 npx tsx src/eval-oss.ts all",
     "bench:tokens": "npx tsx src/eval-tokens.ts",
     "bench:tokens:json": "GMAX_EVAL_JSON=1 npx tsx src/eval-tokens.ts",
+    "bench:surprises": "npx tsx src/eval-surprising-connections.ts",
+    "bench:surprises:json": "GMAX_EVAL_JSON=1 npx tsx src/eval-surprising-connections.ts",
     "format": "biome format --write .",
     "format:check": "biome check .",
     "lint": "biome lint .",

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

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