grepmax 0.23.0 → 0.25.0

package/dist/commands/watch.js

@@ -48,7 +48,6 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const commander_1 = require("commander");
 const config_1 = require("../config");
-const index_config_1 = require("../lib/index/index-config");
 const syncer_1 = require("../lib/index/syncer");
 const watcher_1 = require("../lib/index/watcher");
 const meta_cache_1 = require("../lib/store/meta-cache");
@@ -122,19 +121,51 @@ exports.watch = new commander_1.Command("watch")
             }
             const logFile = path.join(config_1.PATHS.logsDir, "daemon.log");
             const out = (0, log_rotate_1.openRotatedLog)(logFile);
-            const child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], "watch", "--daemon"], {
-                detached: true,
-                stdio: ["ignore", out, out],
-                cwd: process.cwd(),
-                env: Object.assign(Object.assign({}, process.env), { GMAX_BACKGROUND: "true" }),
-            });
+            let child;
+            try {
+                child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], "watch", "--daemon"], {
+                    detached: true,
+                    stdio: ["ignore", out, out],
+                    cwd: process.cwd(),
+                    env: Object.assign(Object.assign({}, process.env), { GMAX_BACKGROUND: "true" }),
+                });
+                yield new Promise((resolve, reject) => {
+                    child.once("spawn", resolve);
+                    child.once("error", reject);
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`Failed to start daemon: ${message}`);
+                process.exitCode = 1;
+                return;
+            }
+            finally {
+                try {
+                    fs.closeSync(out);
+                }
+                catch (_c) { }
+            }
             child.unref();
             console.log(`Daemon started (PID: ${child.pid}, log: ${logFile})`);
             process.exit(0);
         }
         // Daemon foreground
+        // Stamp every daemon.log line so incidents can be correlated with the
+        // timestamped MLX/LLM server logs. Workers inherit via env flag.
+        const { installTimestampedOutput } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/logger")));
+        installTimestampedOutput();
         const { Daemon } = yield Promise.resolve().then(() => __importStar(require("../lib/daemon/daemon")));
         const daemon = new Daemon();
+        process.on("SIGINT", () => daemon.shutdown().then(() => (0, exit_1.gracefulExit)()));
+        process.on("SIGTERM", () => daemon.shutdown().then(() => (0, exit_1.gracefulExit)()));
+        process.on("uncaughtException", (err) => {
+            console.error("[daemon] uncaughtException:", err);
+            daemon.shutdown().then(() => (0, exit_1.gracefulExit)(1));
+        });
+        process.on("unhandledRejection", (reason) => {
+            console.error("[daemon] unhandledRejection:", reason);
+        });
         try {
             yield daemon.start();
         }
@@ -151,19 +182,10 @@ exports.watch = new commander_1.Command("watch")
             try {
                 yield daemon.shutdown();
             }
-            catch (_c) { }
+            catch (_d) { }
             process.exitCode = 1;
             return;
         }
-        process.on("SIGINT", () => daemon.shutdown().then(() => (0, exit_1.gracefulExit)()));
-        process.on("SIGTERM", () => daemon.shutdown().then(() => (0, exit_1.gracefulExit)()));
-        process.on("uncaughtException", (err) => {
-            console.error("[daemon] uncaughtException:", err);
-            daemon.shutdown().then(() => (0, exit_1.gracefulExit)(1));
-        });
-        process.on("unhandledRejection", (reason) => {
-            console.error("[daemon] unhandledRejection:", reason);
-        });
         return;
     }
     // --- Per-project mode ---
@@ -185,12 +207,31 @@ exports.watch = new commander_1.Command("watch")
         const safeName = projectName.replace(/[^a-zA-Z0-9._-]/g, "_");
         const logFile = path.join(config_1.PATHS.logsDir, `watch-${safeName}.log`);
         const out = (0, log_rotate_1.openRotatedLog)(logFile);
-        const child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], ...args], {
-            detached: true,
-            stdio: ["ignore", out, out],
-            cwd: process.cwd(),
-            env: Object.assign(Object.assign({}, process.env), { GMAX_BACKGROUND: "true" }),
-        });
+        let child;
+        try {
+            child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], ...args], {
+                detached: true,
+                stdio: ["ignore", out, out],
+                cwd: process.cwd(),
+                env: Object.assign(Object.assign({}, process.env), { GMAX_BACKGROUND: "true" }),
+            });
+            yield new Promise((resolve, reject) => {
+                child.once("spawn", resolve);
+                child.once("error", reject);
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Failed to start watcher for ${projectName}: ${message}`);
+            process.exitCode = 1;
+            return;
+        }
+        finally {
+            try {
+                fs.closeSync(out);
+            }
+            catch (_e) { }
+        }
         child.unref();
         console.log(`Watcher started for ${projectName} (PID: ${child.pid}, log: ${logFile})`);
         process.exit(0);
@@ -225,24 +266,36 @@ exports.watch = new commander_1.Command("watch")
         .where((0, filter_builder_1.pathStartsWith)(prefix))
         .limit(1)
         .toArray();
+    let degraded = false;
+    let degradedErrors = 0;
+    let initialScanErrors = 0;
+    let initialFailedFiles = 0;
     if (indexed.length === 0) {
         console.log(`[watch:${projectName}] No index found for ${projectRoot}, running initial sync...`);
         const syncResult = yield (0, syncer_1.initialSync)({ projectRoot });
-        // Update registry after sync
-        const globalConfig = (0, index_config_1.readGlobalConfig)();
-        (0, project_registry_1.registerProject)({
-            root: projectRoot,
-            name: projectName,
-            vectorDim: globalConfig.vectorDim,
-            modelTier: globalConfig.modelTier,
-            embedMode: globalConfig.embedMode,
-            lastIndexed: new Date().toISOString(),
-            chunkCount: syncResult.indexed,
-            status: "indexed",
-        });
-        console.log(`[watch:${projectName}] Initial sync complete.`);
+        if (syncResult.degraded) {
+            degraded = true;
+            degradedErrors = syncResult.scanErrors + syncResult.failedFiles;
+            initialScanErrors = syncResult.scanErrors;
+            initialFailedFiles = syncResult.failedFiles;
+            console.warn(`[watch:${projectName}] Initial sync incomplete: ${syncResult.scanErrors} scan error(s), ${syncResult.failedFiles} file failure(s). Preserving pending registry state.`);
+        }
+        else {
+            const chunkCount = yield vectorDb.countRowsForPath(prefix);
+            (0, project_registry_1.stampProjectFullSync)({
+                root: projectRoot,
+                name: projectName,
+                generation: syncResult.generation,
+                embedMode: syncResult.embedMode,
+                chunkCount,
+                chunkerVersion: config_1.CONFIG.CHUNKER_VERSION,
+                expectedFingerprint: syncResult.registryExpectation.embeddingFingerprint,
+                expectedRebuildId: syncResult.registryExpectation.rebuildId,
+            });
+            console.log(`[watch:${projectName}] Initial sync complete.`);
+        }
     }
-    (0, watcher_store_1.updateWatcherStatus)(process.pid, "watching");
+    (0, watcher_store_1.updateWatcherStatus)(process.pid, degraded ? "degraded" : "watching", undefined, degraded ? `${degradedErrors} incomplete scan path(s)` : undefined);
     // Open resources for watcher
     const metaCache = new meta_cache_1.MetaCache(paths.lmdbPath);
     // Start watching
@@ -251,10 +304,17 @@ exports.watch = new commander_1.Command("watch")
         vectorDb,
         metaCache,
         dataDir: paths.dataDir,
+        initialScanErrors,
+        initialFailedFiles,
         onReindex: (files, ms) => {
             console.log(`[watch:${projectName}] Reindexed ${files} file${files !== 1 ? "s" : ""} (${(ms / 1000).toFixed(1)}s)`);
             lastActivity = Date.now();
-            (0, watcher_store_1.updateWatcherStatus)(process.pid, "watching", Date.now());
+            (0, watcher_store_1.updateWatcherStatus)(process.pid, degraded ? "degraded" : "watching", Date.now(), degraded ? `${degradedErrors} incomplete scan path(s)` : undefined);
+        },
+        onHealthChange: (complete, errors) => {
+            degraded = !complete;
+            degradedErrors = errors;
+            (0, watcher_store_1.updateWatcherStatus)(process.pid, complete ? "watching" : "degraded", undefined, complete ? undefined : `${errors} incomplete scan path(s)`);
         },
     });
     console.log(`[watch:${projectName}] File watcher active`);
@@ -300,6 +360,10 @@ exports.watch
         const projects = resp.projects;
         const uptime = Math.floor(resp.uptime / 60);
         console.log(`Daemon (PID: ${resp.pid}, uptime: ${uptime}m):`);
+        const mlx = resp.mlx;
+        if (mlx) {
+            console.log(`  MLX: ${mlx.state} (${mlx.model}${mlx.pid ? `, PID ${mlx.pid}` : ""})${mlx.error ? ` — ${mlx.error}` : ""}`);
+        }
         for (const p of projects) {
             console.log(`  - ${p.root} [${p.status}]`);
         }

package/dist/config.js

@@ -217,6 +217,9 @@ exports.PATHS = {
     globalRoot: GLOBAL_ROOT,
     models: path.join(GLOBAL_ROOT, "models"),
     grammars: path.join(GLOBAL_ROOT, "grammars"),
+    // HF cache for the MLX embed server, pinned to internal disk so the server
+    // survives an unmounted external volume behind the user's HF_HOME.
+    hfDir: path.join(GLOBAL_ROOT, "hf"),
     logsDir: path.join(GLOBAL_ROOT, "logs"),
     daemonSocket: path.join(GLOBAL_ROOT, "daemon.sock"),
     daemonPidFile: path.join(GLOBAL_ROOT, "daemon.pid"),

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);