grepmax 0.22.0 → 0.24.0

package/dist/eval-surprising-connections.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * Measure-first prototype for Graphify Phase 3 "surprising connections".
+ *
+ * It samples indexed code chunks, asks LanceDB for each chunk's nearest vector
+ * neighbors, then filters out pairs that are already obvious. Output is grouped
+ * by file pair and scored for actionability. This is deliberately an eval
+ * harness; the product surface is `gmax surprises --experimental`.
+ *
+ * Run:
+ *   pnpm bench:surprises
+ *   pnpm bench:surprises -- --sample 300 --neighbors 25 --top 30
+ *   pnpm bench:surprises:json
+ */
+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 });
+const path = __importStar(require("node:path"));
+const surprising_connections_1 = require("./lib/analysis/surprising-connections");
+const vector_db_1 = require("./lib/store/vector-db");
+const exit_1 = require("./lib/utils/exit");
+const project_root_1 = require("./lib/utils/project-root");
+function argValue(name) {
+    const prefix = `${name}=`;
+    for (let i = 2; i < process.argv.length; i++) {
+        const arg = process.argv[i];
+        if (arg === name)
+            return process.argv[i + 1];
+        if (arg.startsWith(prefix))
+            return arg.slice(prefix.length);
+    }
+    return undefined;
+}
+function argValues(name) {
+    const values = [];
+    const prefix = `${name}=`;
+    for (let i = 2; i < process.argv.length; i++) {
+        const arg = process.argv[i];
+        if (arg === name && process.argv[i + 1]) {
+            values.push(process.argv[i + 1]);
+            i++;
+        }
+        else if (arg.startsWith(prefix)) {
+            values.push(arg.slice(prefix.length));
+        }
+    }
+    return values.length > 0 ? values : undefined;
+}
+function hasFlag(name) {
+    return process.argv.includes(name);
+}
+function intOpt(name, envName, fallback) {
+    var _a;
+    const raw = (_a = argValue(name)) !== null && _a !== void 0 ? _a : process.env[envName];
+    const parsed = Number.parseInt(raw !== null && raw !== void 0 ? raw : "", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function floatOpt(name, envName, fallback) {
+    var _a;
+    const raw = (_a = argValue(name)) !== null && _a !== void 0 ? _a : process.env[envName];
+    const parsed = Number.parseFloat(raw !== null && raw !== void 0 ? raw : "");
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function run() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const root = path.resolve((_a = argValue("--root")) !== null && _a !== void 0 ? _a : process.cwd());
+        const projectRoot = (_b = (0, project_root_1.findProjectRoot)(root)) !== null && _b !== void 0 ? _b : root;
+        const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+        const vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+        const table = yield vectorDb.ensureTable();
+        const top = intOpt("--top", "GMAX_SURPRISE_TOP", 25);
+        const json = hasFlag("--json") || process.env.GMAX_EVAL_JSON === "1";
+        const log = json ? console.error : console.log;
+        const result = yield (0, surprising_connections_1.analyzeSurprisingConnections)(table, projectRoot, {
+            sample: intOpt("--sample", "GMAX_SURPRISE_SAMPLE", surprising_connections_1.DEFAULT_SURPRISE_OPTIONS.sample),
+            neighbors: intOpt("--neighbors", "GMAX_SURPRISE_NEIGHBORS", surprising_connections_1.DEFAULT_SURPRISE_OPTIONS.neighbors),
+            dirDepth: intOpt("--dir-depth", "GMAX_SURPRISE_DIR_DEPTH", surprising_connections_1.DEFAULT_SURPRISE_OPTIONS.dirDepth),
+            minSimilarity: floatOpt("--min-sim", "GMAX_SURPRISE_MIN_SIM", surprising_connections_1.DEFAULT_SURPRISE_OPTIONS.minSimilarity),
+            maxRows: intOpt("--max-rows", "GMAX_SURPRISE_MAX_ROWS", surprising_connections_1.DEFAULT_SURPRISE_OPTIONS.maxRows),
+            includeTests: hasFlag("--include-tests"),
+            includeEval: hasFlag("--include-eval"),
+            in: argValues("--in"),
+            exclude: argValues("--exclude"),
+        });
+        const { summary, findings } = result;
+        const topFindings = findings.slice(0, top);
+        log(`Surprising-connections prototype: ${summary.sampledAnchors} sampled chunks from ${summary.codeRows} code chunks (${summary.rows} indexed rows)`);
+        if (json) {
+            process.stdout.write(`${JSON.stringify({
+                summary,
+                findings: topFindings.map((finding) => ({
+                    score: finding.score,
+                    maxSimilarity: finding.maxSimilarity,
+                    medianSimilarity: finding.medianSimilarity,
+                    pairCount: finding.pairCount,
+                    files: [finding.fileA, finding.fileB],
+                    reasons: finding.reasons,
+                    topSimilarities: finding.topSimilarities,
+                    representative: {
+                        similarity: Number(finding.representative.similarity.toFixed(3)),
+                        distance: Number(finding.representative.distance.toFixed(3)),
+                        scoreParts: finding.representative.scoreParts,
+                        source: {
+                            file: finding.representative.source.relPath,
+                            line: finding.representative.source.startLine + 1,
+                            symbols: finding.representative.source.definedSymbols.slice(0, 4),
+                            role: finding.representative.source.role,
+                        },
+                        target: {
+                            file: finding.representative.target.relPath,
+                            line: finding.representative.target.startLine + 1,
+                            symbols: finding.representative.target.definedSymbols.slice(0, 4),
+                            role: finding.representative.target.role,
+                        },
+                    },
+                })),
+            }, null, 2)}\n`);
+        }
+        else {
+            console.log("\nSummary");
+            console.log(`  project: ${projectRoot}`);
+            console.log(`  rows/code rows: ${summary.rows}/${summary.codeRows}`);
+            console.log(`  sampled anchors: ${summary.sampledAnchors}`);
+            console.log(`  graph file edges: ${summary.graphFileEdges}`);
+            console.log(`  accepted pairs/file-pairs: ${summary.acceptedPairs}/${summary.acceptedFilePairs}`);
+            console.log(`  similarity p50/p90/max: ${summary.similarity.p50}/${summary.similarity.p90}/${summary.similarity.max}`);
+            console.log(`  score p50/p90/max: ${summary.actionabilityScore.p50}/${summary.actionabilityScore.p90}/${summary.actionabilityScore.max}`);
+            console.log(`  filtered: same-file ${summary.filters.sameFile}, same-dir ${summary.filters.sameDirBucket}, graph-edge ${summary.filters.graphEdge}, tests ${summary.filters.tests}`);
+            console.log("\nTop grouped surprising connections");
+            if (topFindings.length === 0) {
+                console.log("  none");
+            }
+            else {
+                for (const finding of topFindings) {
+                    const pair = finding.representative;
+                    console.log(`  score=${finding.score.toFixed(3)} sim=${finding.maxSimilarity.toFixed(3)} pairs=${finding.pairCount}  ${finding.fileA}`);
+                    console.log(`      <-> ${finding.fileB}`);
+                    console.log(`      best: ${(0, surprising_connections_1.lineLabel)(pair.source)} <-> ${(0, surprising_connections_1.lineLabel)(pair.target)}`);
+                    console.log(`      reasons: ${finding.reasons.join(", ") || "none"}`);
+                }
+            }
+        }
+        yield vectorDb.close();
+        yield (0, exit_1.gracefulExit)(0);
+    });
+}
+run().catch((error) => __awaiter(void 0, void 0, void 0, function* () {
+    console.error(error instanceof Error ? error.stack || error.message : error);
+    yield (0, exit_1.gracefulExit)(1);
+}));

package/dist/index.js

@@ -73,6 +73,7 @@ const similar_1 = require("./commands/similar");
 const skeleton_1 = require("./commands/skeleton");
 const status_1 = require("./commands/status");
 const summarize_1 = require("./commands/summarize");
+const surprises_1 = require("./commands/surprises");
 const symbols_1 = require("./commands/symbols");
 const test_find_1 = require("./commands/test-find");
 const trace_1 = require("./commands/trace");
@@ -129,6 +130,7 @@ commander_1.program.addCommand(diff_1.diff);
 commander_1.program.addCommand(test_find_1.testFind);
 commander_1.program.addCommand(impact_1.impact);
 commander_1.program.addCommand(similar_1.similar);
+commander_1.program.addCommand(surprises_1.surprises);
 commander_1.program.addCommand(context_1.context);
 // Services
 commander_1.program.addCommand(serve_1.serve);