grepmax 0.26.53 → 0.26.54

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "grepmax",
       "source": "./plugins/grepmax",
       "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
-      "version": "0.26.53",
+      "version": "0.26.54",
       "author": {
         "name": "Robert Owens",
         "email": "robowens@me.com"

package/dist/lib/output/mcp-results.js

@@ -47,6 +47,9 @@ exports.compactionSchema = zod_1.z.object({
     freeBytesBefore: zod_1.z.number().optional(),
     freeBytesAfter: zod_1.z.number().optional(),
     bytesReclaimed: zod_1.z.number().optional(),
+    netBytesReclaimed: zod_1.z.number().optional(),
+    cleanupPasses: zod_1.z.number().int().min(0).max(1).optional(),
+    cleanupReason: zod_1.z.string().optional(),
 });
 const embedding = zod_1.z.object({
     tier: zod_1.z.string(),

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

@@ -1108,9 +1108,80 @@ class VectorDB {
         (0, logger_1.log)("vectordb", `Compaction result: ${JSON.stringify(result)}`);
         return Object.assign({}, result);
     }
+    /** Prune the reserve-ID snapshot without another data rewrite. Caller holds
+     * compactingPromise and has drained writes; never use this for retention > 0.
+     * Lance 12 treats one deletion-free fragment as a compaction no-op. */
+    cleanupCompactionReservation(table) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let passes = 0;
+            const deferred = (reason) => ({
+                passes: 0,
+                bytesRemoved: 0,
+                reason,
+            });
+            try {
+                const stats = yield table.stats();
+                if (((_a = stats.fragmentStats) === null || _a === void 0 ? void 0 : _a.numFragments) !== 1) {
+                    return deferred("cleanup deferred: table is not a single fragment");
+                }
+                const version = yield table.version();
+                const fresh = yield this.openExistingTableUnsafe();
+                if (!fresh || (yield fresh.version()) !== version) {
+                    return deferred("cleanup deferred: table changed after compaction");
+                }
+                const latest = (yield fresh.listVersions()).find((v) => v.version === version);
+                if ((latest === null || latest === void 0 ? void 0 : latest.metadata.total_fragments) !== "1" ||
+                    latest.metadata.total_deletion_files !== "0" ||
+                    latest.metadata.total_deletion_file_rows !== "0") {
+                    return deferred("cleanup deferred: deletion-free fragment not verified");
+                }
+                // Manifest timestamps have sub-ms precision; wait for a real later tick,
+                // never invent a future cutoff. No gmax writes can enter while gated.
+                yield new Promise((resolve) => setTimeout(resolve, 1));
+                const cutoff = new Date();
+                if (!Number.isFinite(latest.timestamp.getTime()) ||
+                    cutoff.getTime() <= latest.timestamp.getTime()) {
+                    return deferred("cleanup deferred: clock has not passed the commit");
+                }
+                const freeBytes = this.getAvailableBytes();
+                const requiredBytes = stats.totalBytes * 2 + config_1.DISK_CRITICAL_BYTES;
+                if (!Number.isFinite(stats.totalBytes) ||
+                    stats.totalBytes < 0 ||
+                    freeBytes < requiredBytes) {
+                    return deferred("cleanup deferred: insufficient rewrite headroom");
+                }
+                (0, logger_1.log)("vectordb", `Compaction cleanup attempt: ${JSON.stringify({ version, cutoff: cutoff.getTime(), freeBytes, requiredBytes })}`);
+                passes = 1;
+                const result = yield fresh.optimize({
+                    cleanupOlderThan: cutoff,
+                    deleteUnverified: true,
+                });
+                if (result.compaction.fragmentsRemoved !== 0 ||
+                    result.compaction.fragmentsAdded !== 0) {
+                    return {
+                        passes,
+                        bytesRemoved: result.prune.bytesRemoved,
+                        failed: true,
+                        reason: "cleanup unexpectedly rewrote data; no retry",
+                    };
+                }
+                return { passes, bytesRemoved: result.prune.bytesRemoved };
+            }
+            catch (error) {
+                return {
+                    passes,
+                    bytesRemoved: 0,
+                    failed: true,
+                    reason: `cleanup failed: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+        });
+    }
     optimize() {
         return __awaiter(this, arguments, void 0, function* (retries = COMPACTION_MAX_ATTEMPTS, retentionMs = 0, bypassExclusiveMutation = false) {
             var _a;
+            var _b;
             if (!bypassExclusiveMutation) {
                 while (this.exclusiveMutationPromise)
                     yield this.exclusiveMutationPromise;
@@ -1120,7 +1191,7 @@ class VectorDB {
             if (this.compactingPromise) {
                 (0, logger_1.debug)("vectordb", "Optimize already in progress, skipping");
                 yield this.compactingPromise;
-                return ((_a = this.compactionStatus()) !== null && _a !== void 0 ? _a : (0, compaction_result_1.skippedCompaction)("compaction unavailable"));
+                return ((_b = this.compactionStatus()) !== null && _b !== void 0 ? _b : (0, compaction_result_1.skippedCompaction)("compaction unavailable"));
             }
             this.lastOptimizeDidWork = false;
             let resolveCompacting;
@@ -1133,7 +1204,10 @@ class VectorDB {
             let logicalBytes;
             let diskBytesBefore;
             let freeBytesBefore;
+            let cleanupPasses = 0;
+            let cleanupReason;
             const finish = (status, reason, bytesReclaimed) => {
+                const diskBytesAfter = this.getDirectorySize(this.lancedbDir);
                 const result = {
                     status,
                     at: Date.now(),
@@ -1143,9 +1217,14 @@ class VectorDB {
                     logicalBytes,
                     diskBytesBefore,
                     freeBytesBefore,
-                    diskBytesAfter: this.getDirectorySize(this.lancedbDir),
+                    diskBytesAfter,
                     freeBytesAfter: this.getAvailableBytes(),
                     bytesReclaimed,
+                    netBytesReclaimed: diskBytesBefore === undefined
+                        ? undefined
+                        : diskBytesBefore - diskBytesAfter,
+                    cleanupPasses,
+                    cleanupReason,
                 };
                 this.lastCompactionResult = result;
                 (0, logger_1.log)("vectordb", `Compaction result: ${JSON.stringify(result)}`);
@@ -1210,7 +1289,18 @@ class VectorDB {
                         else {
                             (0, logger_1.debug)("vectordb", "Optimize: nothing to compact or prune");
                         }
-                        return finish("completed", undefined, prune.bytesRemoved);
+                        let bytesReclaimed = prune.bytesRemoved;
+                        if (retentionMs === 0 && compaction.fragmentsRemoved > 0) {
+                            const cleanup = yield this.cleanupCompactionReservation(table);
+                            cleanupPasses = cleanup.passes;
+                            cleanupReason = (_a = cleanup.reason) === null || _a === void 0 ? void 0 : _a.replace(/[\r\n\t]/g, " ").slice(0, 512);
+                            bytesReclaimed += cleanup.bytesRemoved;
+                            this.lastOptimizeDidWork || (this.lastOptimizeDidWork = cleanup.bytesRemoved > 0);
+                            (0, logger_1.log)("vectordb", `Compaction cleanup result: ${JSON.stringify(Object.assign(Object.assign({}, cleanup), { reason: cleanupReason }))}`);
+                            if (cleanup.failed)
+                                return finish("failed", cleanupReason, bytesReclaimed);
+                        }
+                        return finish("completed", undefined, bytesReclaimed);
                     }
                     catch (e) {
                         const msg = e instanceof Error ? e.message : String(e);
@@ -1337,7 +1427,7 @@ class VectorDB {
                     // call, so a productive first pass followed by a barren bloat retry would
                     // otherwise read as unproductive and trigger a spurious backoff.
                     let didWork = this.lastOptimizeDidWork;
-                    if (this.lastOptimizeDidWork) {
+                    if (result.status === "completed" && this.lastOptimizeDidWork) {
                         const table = yield this.openExistingTableUnsafe();
                         if (table) {
                             // Collect abandoned scratch files before measuring. They are pure

package/dist/lib/utils/doctor-optimize.js

@@ -72,6 +72,12 @@ function formatDoctorOptimize(report, agent) {
             ...(typeof (r === null || r === void 0 ? void 0 : r.bytesReclaimed) === "number"
                 ? [`bytes_reclaimed=${r.bytesReclaimed}`]
                 : []),
+            ...(typeof (r === null || r === void 0 ? void 0 : r.netBytesReclaimed) === "number"
+                ? [`net_bytes_reclaimed=${r.netBytesReclaimed}`]
+                : []),
+            ...(typeof (r === null || r === void 0 ? void 0 : r.cleanupPasses) === "number"
+                ? [`cleanup_passes=${r.cleanupPasses}`]
+                : []),
             ...(reason ? [`reason=${reason}`] : []),
         ].join("\t");
     }

package/package.json

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