grepmax 0.26.40 → 0.26.42

package/dist/lib/store/vector-db.js

@@ -188,6 +188,9 @@ const COMPACTION_MIN_INTERVAL_MS = 30 * 60 * 1000;
  * so a store that cannot be improved stops paying for the attempt.
  */
 const COMPACTION_MAX_INTERVAL_MS = 6 * 60 * 60 * 1000;
+// Failed rewrites leave complete fragment copies until a later successful prune.
+// One fresh-snapshot retry is enough; five attempts stranded ~70 GB in Oct 2026.
+const COMPACTION_MAX_ATTEMPTS = 2;
 /**
  * Bounds for LanceDB's per-connection caches.
  *
@@ -1083,7 +1086,7 @@ class VectorDB {
         });
     }
     optimize() {
-        return __awaiter(this, arguments, void 0, function* (retries = 5, retentionMs = 0, bypassExclusiveMutation = false) {
+        return __awaiter(this, arguments, void 0, function* (retries = COMPACTION_MAX_ATTEMPTS, retentionMs = 0, bypassExclusiveMutation = false) {
             if (!bypassExclusiveMutation) {
                 while (this.exclusiveMutationPromise)
                     yield this.exclusiveMutationPromise;
@@ -1102,12 +1105,28 @@ class VectorDB {
             });
             this.activeCompactions++;
             try {
-                const table = yield this.ensureTableUnsafe();
-                const cutoff = new Date(Date.now() - retentionMs);
+                const maxAttempts = Math.min(retries, COMPACTION_MAX_ATTEMPTS);
                 let rebuiltFts = false;
-                for (let attempt = 1; attempt <= retries; attempt++) {
+                for (let attempt = 1; attempt <= maxAttempts; attempt++) {
                     yield this.drainWrites();
                     try {
+                        // Open AFTER outstanding writes commit, and reopen on every retry.
+                        // A handle opened before drainWrites carries the old snapshot even
+                        // though new writes are gated. Reusing it repeats the same conflict.
+                        const table = yield this.ensureTableUnsafe();
+                        const { totalBytes } = yield table.stats();
+                        if (!Number.isFinite(totalBytes) || totalBytes < 0) {
+                            throw new Error("Cannot estimate compaction size from table stats");
+                        }
+                        // Bypass the cached pressure check: a failed attempt can consume a
+                        // whole table within its 30s cache window. Budget two logical copies
+                        // for rewrite/index overhead, leaving the critical reserve untouched.
+                        const availableBytes = this.getAvailableBytes();
+                        const requiredBytes = totalBytes * 2 + config_1.DISK_CRITICAL_BYTES;
+                        if (availableBytes < requiredBytes) {
+                            (0, logger_1.log)("vectordb", `Optimize skipped: insufficient rewrite headroom (${(availableBytes / Math.pow(1024, 3)).toFixed(1)}GB free, ${(requiredBytes / Math.pow(1024, 3)).toFixed(1)}GB required)`);
+                            return;
+                        }
                         const done = (0, logger_1.timer)("vectordb", "optimize");
                         // deleteUnverified deletes files Lance cannot prove are unreferenced.
                         // LanceDB's own docs: only safe "if you can guarantee that no other
@@ -1119,7 +1138,8 @@ class VectorDB {
                         // Anything new that calls optimize() must preserve that: either be the
                         // daemon, or be the only process on the store.
                         const stats = yield table.optimize({
-                            cleanupOlderThan: cutoff,
+                            // Include fragment copies left by earlier failed attempts.
+                            cleanupOlderThan: new Date(Date.now() - retentionMs),
                             deleteUnverified: true,
                         });
                         done();
@@ -1150,10 +1170,10 @@ class VectorDB {
                             (0, logger_1.log)("vectordb", `Optimize failed (ENOSPC): disk full — skipping retries`);
                             return;
                         }
-                        if (attempt < retries &&
+                        if (attempt < maxAttempts &&
                             (msg.includes("conflict") || msg.includes("Retryable"))) {
                             const delay = 1000 * Math.pow(2, (attempt - 1));
-                            (0, logger_1.log)("vectordb", `Optimize conflict (attempt ${attempt}/${retries}), retrying in ${delay}ms`);
+                            (0, logger_1.log)("vectordb", `Optimize conflict (attempt ${attempt}/${maxAttempts}), retrying with a fresh snapshot in ${delay}ms`);
                             yield new Promise((r) => setTimeout(r, delay));
                             continue;
                         }
@@ -1165,7 +1185,7 @@ class VectorDB {
                         // Unsafe variant: the public createFTSIndex waits on
                         // compactingPromise, which we hold.
                         if (msg.includes("Panic")) {
-                            if (attempt < retries &&
+                            if (attempt < maxAttempts &&
                                 !rebuiltFts &&
                                 !this.ftsPanicRecoveryExhausted) {
                                 rebuiltFts = true;

package/dist/lib/utils/resource-snapshot.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildResourceSnapshot = buildResourceSnapshot;
+function buildResourceSnapshot(counters, memory = process.memoryUsage(), at = Date.now()) {
+    const mb = (bytes) => Math.round(bytes / 1024 / 1024);
+    return {
+        at,
+        reason: counters.reason,
+        footprintMb: counters.footprintMb,
+        rssMb: mb(memory.rss),
+        heapUsedMb: mb(memory.heapUsed),
+        externalMb: mb(memory.external),
+        arrayBuffersMb: mb(memory.arrayBuffers),
+        lanceCacheMb: counters.lanceCacheBytes === null ? null : mb(counters.lanceCacheBytes),
+        workers: counters.workers,
+        pendingFiles: counters.pendingFiles,
+        operations: counters.operations,
+        maintenance: counters.maintenance,
+    };
+}

package/dist/lib/utils/tests-footer.js

@@ -15,6 +15,7 @@ exports.fetchTestsForFooter = fetchTestsForFooter;
 exports.renderTestsFooterAgent = renderTestsFooterAgent;
 exports.renderTestsFooterHuman = renderTestsFooterHuman;
 const impact_1 = require("../graph/impact");
+const test_hits_1 = require("../graph/test-hits");
 /**
  * The footer is a courtesy line under a body the user asked for; it must never
  * make the command feel slow. Past this budget the lookup is abandoned and the
@@ -57,24 +58,10 @@ function fetchTestsForFooter(symbol, vectorDb, pathPrefix, excludePrefixes) {
 function relPath(p, projectRoot) {
     return p.startsWith(`${projectRoot}/`) ? p.slice(projectRoot.length + 1) : p;
 }
-function hopLabelAgent(hops) {
-    if (hops === -1)
-        return "via-import";
-    if (hops === 0)
-        return "direct";
-    return `${hops}-hop`;
-}
-function hopLabelHuman(hops) {
-    if (hops === -1)
-        return "via import";
-    if (hops === 0)
-        return "direct";
-    return `${hops} hop${hops > 1 ? "s" : ""}`;
-}
 function renderTestsFooterAgent(tests, projectRoot) {
     const lines = [];
     for (const t of tests.slice(0, MAX_SHOWN)) {
-        lines.push(`t: ${relPath(t.file, projectRoot)}:${t.line + 1}\t${t.symbol}\t${hopLabelAgent(t.hops)}`);
+        lines.push(`t: ${relPath(t.file, projectRoot)}:${t.line + 1}\t${t.symbol}\t${(0, test_hits_1.hopLabelAgent)(t.hops, t.evidence)}`);
     }
     if (tests.length > MAX_SHOWN) {
         lines.push(`t: ... ${tests.length - MAX_SHOWN} more`);
@@ -86,7 +73,12 @@ function renderTestsFooterHuman(tests, projectRoot) {
     lines.push("");
     lines.push(`tests (${tests.length}):`);
     for (const t of tests.slice(0, MAX_SHOWN)) {
-        lines.push(`  ${t.symbol.padEnd(25)} ${dim(`${relPath(t.file, projectRoot)}:${t.line + 1}`)} ${dim(`(${hopLabelHuman(t.hops)})`)}`);
+        const label = t.evidence
+            ? "same-file candidate"
+            : t.hops === -1
+                ? "via import"
+                : (0, test_hits_1.hopLabelAgent)(t.hops);
+        lines.push(`  ${t.symbol.padEnd(25)} ${dim(`${relPath(t.file, projectRoot)}:${t.line + 1}`)} ${dim(`(${label})`)}`);
     }
     if (tests.length > MAX_SHOWN) {
         lines.push(dim(`  ... and ${tests.length - MAX_SHOWN} more`));

package/dist/lib/workers/embedding-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddingBackendUnavailableError = void 0;
+exports.isEmbeddingBackendUnavailable = isEmbeddingBackendUnavailable;
+/** Shared backend outages are retryable; malformed inputs/protocols are not. */
+class EmbeddingBackendUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = "EMBED_BACKEND_UNAVAILABLE";
+        this.name = "EmbeddingBackendUnavailableError";
+    }
+}
+exports.EmbeddingBackendUnavailableError = EmbeddingBackendUnavailableError;
+function isEmbeddingBackendUnavailable(error) {
+    return ((error === null || error === void 0 ? void 0 : error.code) === "EMBED_BACKEND_UNAVAILABLE");
+}

package/dist/lib/workers/embeddings/mlx-client.js

@@ -48,6 +48,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateMlxEmbeddingResponse = validateMlxEmbeddingResponse;
+exports.requestMlxJSON = requestMlxJSON;
 exports.isMlxUp = isMlxUp;
 exports.mlxEmbed = mlxEmbed;
 const http = __importStar(require("node:http"));
@@ -81,81 +82,108 @@ function validateMlxEmbeddingResponse(data, textCount, expectedModel, expectedDi
                 Number.isFinite(element) &&
                 Math.abs(element) <= FLOAT32_MAX)));
 }
-function postJSON(reqPath, body) {
+/** A hard deadline also bounds stalled/truncated response bodies. */
+function requestMlxJSON(reqPath, body) {
     const start = performance.now();
     return new Promise((resolve) => {
-        const payload = JSON.stringify(body);
+        const payload = body === undefined ? undefined : JSON.stringify(body);
+        let settled = false;
+        let deadline;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(deadline);
+            resolve(Object.assign(Object.assign({}, result), { ms: Math.round(performance.now() - start) }));
+        };
         const req = http.request({
             hostname: MLX_HOST,
             port: MLX_PORT,
             path: reqPath,
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "Content-Length": Buffer.byteLength(payload),
-            },
-            timeout: MLX_TIMEOUT_MS,
+            method: payload === undefined ? "GET" : "POST",
+            headers: payload === undefined
+                ? undefined
+                : {
+                    "Content-Type": "application/json",
+                    "Content-Length": Buffer.byteLength(payload),
+                },
         }, (res) => {
             const chunks = [];
-            res.on("data", (chunk) => chunks.push(chunk));
+            let bytes = 0;
+            res.on("data", (chunk) => {
+                bytes += chunk.length;
+                if (bytes > 16 * 1024 * 1024) {
+                    finish({
+                        ok: false,
+                        category: "protocol",
+                        status: res.statusCode,
+                        detail: "response exceeds 16MiB",
+                    });
+                    req.destroy();
+                }
+                else
+                    chunks.push(chunk);
+            });
+            res.on("aborted", () => finish({
+                ok: false,
+                category: "transport",
+                status: res.statusCode,
+                detail: "response aborted",
+            }));
+            res.on("error", (err) => finish({
+                ok: false,
+                category: "transport",
+                status: res.statusCode,
+                detail: err.message.slice(0, 512),
+            }));
             res.on("end", () => {
+                const raw = Buffer.concat(chunks).toString("utf8");
+                if (res.statusCode !== 200) {
+                    finish({
+                        ok: false,
+                        category: "http",
+                        status: res.statusCode,
+                        detail: raw.slice(0, 512),
+                    });
+                    return;
+                }
                 try {
-                    const data = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
-                    const ok = res.statusCode === 200;
-                    (0, logger_1.debug)("mlx", `POST ${reqPath} → ${res.statusCode} ${(performance.now() - start).toFixed(0)}ms payload=${payload.length}B`);
-                    resolve({ ok, data });
+                    finish({ ok: true, status: res.statusCode, data: JSON.parse(raw) });
                 }
                 catch (_a) {
-                    (0, logger_1.debug)("mlx", `POST ${reqPath} → parse error ${(performance.now() - start).toFixed(0)}ms`);
-                    resolve({ ok: false });
+                    finish({
+                        ok: false,
+                        category: "protocol",
+                        status: res.statusCode,
+                        detail: "invalid JSON",
+                    });
                 }
             });
         });
-        req.on("error", (err) => {
-            (0, logger_1.debug)("mlx", `POST ${reqPath} → error: ${err.message} ${(performance.now() - start).toFixed(0)}ms`);
-            resolve({ ok: false });
-        });
-        req.on("timeout", () => {
-            (0, logger_1.debug)("mlx", `POST ${reqPath} → timeout after ${MLX_TIMEOUT_MS}ms`);
+        req.on("error", (err) => finish({
+            ok: false,
+            category: "transport",
+            detail: err.message.slice(0, 512),
+        }));
+        deadline = setTimeout(() => {
+            finish({
+                ok: false,
+                category: "timeout",
+                detail: "request deadline exceeded",
+            });
             req.destroy();
-            resolve({ ok: false });
-        });
-        req.write(payload);
-        req.end();
+        }, reqPath === "/health" ? 2000 : MLX_TIMEOUT_MS);
+        req.end(payload);
     });
 }
-/**
- * Check if MLX server is reachable. Caches result for CHECK_INTERVAL_MS.
- */
 function checkHealth(expectedModel) {
     return __awaiter(this, void 0, void 0, function* () {
-        const start = performance.now();
-        return new Promise((resolve) => {
-            const req = http.get({ hostname: MLX_HOST, port: MLX_PORT, path: "/health", timeout: 2000 }, (res) => {
-                const chunks = [];
-                res.on("data", (chunk) => chunks.push(chunk));
-                res.on("end", () => {
-                    let model;
-                    try {
-                        model = JSON.parse(Buffer.concat(chunks).toString("utf8")).model;
-                    }
-                    catch (_a) { }
-                    const ok = res.statusCode === 200 &&
-                        (!expectedModel || model === expectedModel);
-                    (0, logger_1.debug)("mlx", `health → ${ok ? "ok" : `status=${res.statusCode} model=${String(model)}`} ${(performance.now() - start).toFixed(0)}ms`);
-                    resolve(ok);
-                });
-            });
-            req.on("error", (err) => {
-                (0, logger_1.debug)("mlx", `health → error: ${err.message} ${(performance.now() - start).toFixed(0)}ms`);
-                resolve(false);
-            });
-            req.on("timeout", () => {
-                (0, logger_1.debug)("mlx", `health → timeout ${(performance.now() - start).toFixed(0)}ms`);
-                req.destroy();
-                resolve(false);
-            });
-        });
+        var _a;
+        var _b, _c;
+        const result = yield requestMlxJSON("/health");
+        const ok = result.ok && (!expectedModel || ((_a = result.data) === null || _a === void 0 ? void 0 : _a.model) === expectedModel);
+        (0, logger_1.debug)("mlx", `health ok=${ok} category=${(_b = result.category) !== null && _b !== void 0 ? _b : "none"} status=${(_c = result.status) !== null && _c !== void 0 ? _c : "none"} ms=${result.ms}`);
+        return ok;
     });
 }
 function isMlxUp(expectedModel) {
@@ -192,7 +220,7 @@ function isMlxUp(expectedModel) {
  */
 function mlxEmbed(texts, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
+        var _a, _b, _c, _d, _e, _f, _g;
         const mode = (_a = options === null || options === void 0 ? void 0 : options.mode) !== null && _a !== void 0 ? _a : EMBED_MODE;
         if (mode === "cpu")
             return null;
@@ -201,7 +229,7 @@ function mlxEmbed(texts, options) {
         (0, logger_1.debug)("mlx", `embed ${texts.length} texts`);
         let postResult;
         try {
-            postResult = yield postJSON("/embed", {
+            postResult = yield requestMlxJSON("/embed", {
                 texts,
                 expected_model: options === null || options === void 0 ? void 0 : options.expectedModel,
             });
@@ -223,17 +251,17 @@ function mlxEmbed(texts, options) {
             const now = Date.now();
             if (wasPreviouslyAvailable ||
                 now - lastMlxWarning >= MLX_WARNING_INTERVAL_MS) {
-                console.error("[mlx] Embed server failed: bad response (ok=" +
-                    ok +
-                    ", validResponse=" +
-                    responseMatches +
-                    ", dim=" +
-                    String(data === null || data === void 0 ? void 0 : data.dim) +
-                    ", model=" +
-                    String(data === null || data === void 0 ? void 0 : data.model) +
-                    ")");
+                console.error(`[mlx] Embed failed: category=${(_b = postResult.category) !== null && _b !== void 0 ? _b : "protocol"} status=${(_c = postResult.status) !== null && _c !== void 0 ? _c : "none"} ms=${postResult.ms} batch=${texts.length} detail=${JSON.stringify((_d = postResult.detail) !== null && _d !== void 0 ? _d : `invalid vectors/model: dim=${String(data === null || data === void 0 ? void 0 : data.dim)} model=${String(data === null || data === void 0 ? void 0 : data.model)}`).slice(0, 600)}`);
                 lastMlxWarning = now;
             }
+            if ((postResult.ok && !responseMatches) ||
+                postResult.category === "protocol" ||
+                (postResult.category === "http" &&
+                    ((_e = postResult.status) !== null && _e !== void 0 ? _e : 500) < 500 &&
+                    postResult.status !== 429 &&
+                    postResult.status !== 408)) {
+                throw new Error(`MLX embedding protocol failure: status=${(_f = postResult.status) !== null && _f !== void 0 ? _f : "none"} ${(_g = postResult.detail) !== null && _g !== void 0 ? _g : "invalid vectors or model identity"}`);
+            }
             return null;
         }
         return data.vectors.map((v) => new Float32Array(v));

package/dist/lib/workers/orchestrator.js

@@ -58,6 +58,7 @@ const file_utils_1 = require("../utils/file-utils");
 const logger_1 = require("../utils/logger");
 const path_containment_1 = require("../utils/path-containment");
 const colbert_math_1 = require("./colbert-math");
+const embedding_error_1 = require("./embedding-error");
 const colbert_1 = require("./embeddings/colbert");
 const granite_1 = require("./embeddings/granite");
 const mlx_client_1 = require("./embeddings/mlx-client");
@@ -158,10 +159,10 @@ class WorkerOrchestrator {
                         expectedDim: this.generation.vectorDim,
                     });
                 if (!mlxResult && !this.allowOnnxFallback) {
-                    throw new Error(`MLX embedding model ${this.generation.mlxModel} is unavailable; ONNX fallback is disabled for this custom embedding generation`);
+                    throw new embedding_error_1.EmbeddingBackendUnavailableError(`MLX embedding model ${this.generation.mlxModel} is unavailable; ONNX fallback is disabled for this custom embedding generation`);
                 }
                 if (!mlxResult && denseBackend === "mlx") {
-                    throw new Error(`MLX embedding model ${this.generation.mlxModel} became unavailable during this embedding operation`);
+                    throw new embedding_error_1.EmbeddingBackendUnavailableError(`MLX embedding model ${this.generation.mlxModel} became unavailable during this embedding operation`);
                 }
                 if (!mlxResult && !mlxFallbackWarned) {
                     console.warn("[embed] MLX unavailable, falling back to CPU (ONNX)");

package/dist/lib/workers/pool.js

@@ -384,7 +384,7 @@ class WorkerPool {
             if ("error" in msg) {
                 const filePath = (_f = (_e = (_a = task.payload) === null || _a === void 0 ? void 0 : _a.path) !== null && _e !== void 0 ? _e : (_b = task.payload) === null || _b === void 0 ? void 0 : _b.absolutePath) !== null && _f !== void 0 ? _f : "unknown";
                 (0, logger_1.debug)("pool", `error task=${task.id} method=${task.method} file=${filePath}: ${msg.error}`);
-                task.reject(new Error(msg.error));
+                task.reject(Object.assign(new Error(msg.error), typeof msg.code === "string" ? { code: msg.code } : {}));
             }
             else {
                 const elapsed = task.startTime

package/dist/lib/workers/process-child.js

@@ -93,7 +93,8 @@ const handleMessage = (msg) => __awaiter(void 0, void 0, void 0, function* () {
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         (0, logger_1.debug)("worker", `fail task=${id} method=${method} ${(performance.now() - start).toFixed(0)}ms: ${message}`);
-        send({ id, error: message });
+        const code = err === null || err === void 0 ? void 0 : err.code;
+        send(Object.assign({ id, error: message }, (typeof code === "string" ? { code } : {})));
     }
 });
 const handleMessageSerially = (0, serialized_handler_1.createSerializedHandler)(handleMessage);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.40",
+  "version": "0.26.42",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -86,7 +86,6 @@
     "cli-highlight": "^2.1.11",
     "commander": "^15.0.0",
     "dotenv": "^17.4.2",
-    "fast-glob": "^3.3.3",
     "ignore": "^7.0.9",
     "lmdb": "^3.5.6",
     "numkong": "^7.8.2",

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

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