grepmax 0.7.29 → 0.7.30

package/dist/lib/index/syncer.js

@@ -50,6 +50,7 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSummaries = generateSummaries;
+exports.computeStaleFiles = computeStaleFiles;
 exports.initialSync = initialSync;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -178,6 +179,9 @@ function createNoopMetaCache() {
         close: () => __awaiter(this, void 0, void 0, function* () { }),
     };
 }
+function computeStaleFiles(cachedPaths, seenPaths) {
+    return Array.from(cachedPaths).filter((p) => !seenPaths.has(p));
+}
 function initialSync(options) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, e_1, _b, _c;
@@ -465,7 +469,7 @@ function initialSync(options) {
                     : new Error(String(flushError));
             }
             // Stale cleanup: only remove paths scoped to this project's root
-            const stale = Array.from(cachedPaths).filter((p) => !seenPaths.has(p));
+            const stale = computeStaleFiles(cachedPaths, seenPaths);
             if (!dryRun && stale.length > 0 && !shouldSkipCleanup) {
                 (0, logger_1.log)("index", `Stale cleanup: ${stale.length} paths`);
                 yield vectorDb.deletePaths(stale);

package/dist/lib/index/watcher-batch.js

@@ -0,0 +1,149 @@
+"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;
+    };
+})();
+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 });
+exports.processBatchCore = processBatchCore;
+exports.flushBatchToDb = flushBatchToDb;
+exports.computeRetryAction = computeRetryAction;
+const fs = __importStar(require("node:fs"));
+const cache_check_1 = require("../utils/cache-check");
+const file_utils_1 = require("../utils/file-utils");
+function processBatchCore(batch, metaCache, pool) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let reindexed = 0;
+        const changedIds = [];
+        const deletes = [];
+        const vectors = [];
+        const metaUpdates = new Map();
+        const metaDeletes = [];
+        for (const [absPath, event] of batch) {
+            if (event === "unlink") {
+                deletes.push(absPath);
+                metaDeletes.push(absPath);
+                reindexed++;
+                continue;
+            }
+            try {
+                const stats = yield fs.promises.stat(absPath);
+                if (!(0, file_utils_1.isIndexableFile)(absPath, stats.size))
+                    continue;
+                const cached = metaCache.get(absPath);
+                if ((0, cache_check_1.isFileCached)(cached, stats)) {
+                    continue;
+                }
+                const result = yield pool.processFile({
+                    path: absPath,
+                    absolutePath: absPath,
+                });
+                const metaEntry = {
+                    hash: result.hash,
+                    mtimeMs: result.mtimeMs,
+                    size: result.size,
+                };
+                if (cached && cached.hash === result.hash) {
+                    metaUpdates.set(absPath, metaEntry);
+                    continue;
+                }
+                if (result.shouldDelete) {
+                    deletes.push(absPath);
+                    metaUpdates.set(absPath, metaEntry);
+                    reindexed++;
+                    continue;
+                }
+                deletes.push(absPath);
+                if (result.vectors.length > 0) {
+                    vectors.push(...result.vectors);
+                    for (const v of result.vectors) {
+                        changedIds.push(v.id);
+                    }
+                }
+                metaUpdates.set(absPath, metaEntry);
+                reindexed++;
+            }
+            catch (err) {
+                const code = err === null || err === void 0 ? void 0 : err.code;
+                if (code === "ENOENT") {
+                    deletes.push(absPath);
+                    metaDeletes.push(absPath);
+                    reindexed++;
+                }
+            }
+        }
+        return { reindexed, changedIds, vectors, deletes, metaUpdates, metaDeletes };
+    });
+}
+function flushBatchToDb(result, vectorDb) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const newIds = result.vectors.map((v) => v.id);
+        if (result.vectors.length > 0) {
+            yield vectorDb.insertBatch(result.vectors);
+        }
+        if (result.deletes.length > 0) {
+            if (newIds.length > 0) {
+                yield vectorDb.deletePathsExcludingIds(result.deletes, newIds);
+            }
+            else {
+                yield vectorDb.deletePaths(result.deletes);
+            }
+        }
+    });
+}
+function computeRetryAction(batch, retryCount, maxRetries, isLockError, consecutiveLockFailures, debounceMs) {
+    var _a;
+    const requeued = new Map();
+    let dropped = 0;
+    for (const [absPath, event] of batch) {
+        const count = ((_a = retryCount.get(absPath)) !== null && _a !== void 0 ? _a : 0) + 1;
+        if (count >= maxRetries) {
+            retryCount.delete(absPath);
+            dropped++;
+        }
+        else {
+            requeued.set(absPath, event);
+            retryCount.set(absPath, count);
+        }
+    }
+    const effectiveFailures = isLockError ? consecutiveLockFailures + 1 : 0;
+    const backoffMs = Math.min(debounceMs * Math.pow(2, effectiveFailures), 30000);
+    return { requeued, dropped, backoffMs };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.7.29",
+  "version": "0.7.30",
   "author": "Robert Owens <robowens@me.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

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

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