grepmax 0.7.29 → 0.7.31

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/dist/lib/index/watcher.js

@@ -103,11 +103,18 @@ function startWatcher(opts) {
             clearTimeout(debounceTimer);
         debounceTimer = setTimeout(() => processBatch(), DEBOUNCE_MS);
     };
+    const BATCH_TIMEOUT_MS = 120000;
     const processBatch = () => __awaiter(this, void 0, void 0, function* () {
         var _a;
         if (closed || processing || pending.size === 0)
             return;
         processing = true;
+        const batchTimeout = setTimeout(() => {
+            if (processing) {
+                console.error("[watch] Batch processing timed out after 120s, resetting");
+                processing = false;
+            }
+        }, BATCH_TIMEOUT_MS);
         const batch = new Map(pending);
         pending.clear();
         (0, logger_1.log)("watch", `Processing ${batch.size} changed files`);
@@ -209,39 +216,6 @@ function startWatcher(opts) {
             finally {
                 yield lock.release();
             }
-            // Summarize new/changed chunks outside the lock (sequential, no GPU contention)
-            if (changedIds.length > 0) {
-                try {
-                    const table = yield vectorDb.ensureTable();
-                    for (const id of changedIds) {
-                        const escaped = (0, filter_builder_1.escapeSqlString)(id);
-                        const rows = yield table
-                            .query()
-                            .select(["id", "path", "content"])
-                            .where(`id = '${escaped}'`)
-                            .limit(1)
-                            .toArray();
-                        if (rows.length === 0)
-                            continue;
-                        const r = rows[0];
-                        const lang = path.extname(String(r.path || "")).replace(/^\./, "") ||
-                            "unknown";
-                        const summaries = yield (0, llm_client_1.summarizeChunks)([
-                            {
-                                code: String(r.content || ""),
-                                language: lang,
-                                file: String(r.path || ""),
-                            },
-                        ]);
-                        if (summaries === null || summaries === void 0 ? void 0 : summaries[0]) {
-                            yield vectorDb.updateRows([id], "summary", [summaries[0]]);
-                        }
-                    }
-                }
-                catch (_b) {
-                    // Summarizer unavailable — skip silently
-                }
-            }
             if (reindexed > 0) {
                 const duration = Date.now() - start;
                 onReindex === null || onReindex === void 0 ? void 0 : onReindex(reindexed, duration);
@@ -280,12 +254,48 @@ function startWatcher(opts) {
             }
         }
         finally {
+            clearTimeout(batchTimeout);
             processing = false;
             // Process any events that came in while we were processing
             if (pending.size > 0) {
                 scheduleBatch();
             }
         }
+        // Fire-and-forget summarization — doesn't block the next batch
+        if (changedIds.length > 0) {
+            (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const table = yield vectorDb.ensureTable();
+                    for (const id of changedIds) {
+                        const escaped = (0, filter_builder_1.escapeSqlString)(id);
+                        const rows = yield table
+                            .query()
+                            .select(["id", "path", "content"])
+                            .where(`id = '${escaped}'`)
+                            .limit(1)
+                            .toArray();
+                        if (rows.length === 0)
+                            continue;
+                        const r = rows[0];
+                        const lang = path.extname(String(r.path || "")).replace(/^\./, "") ||
+                            "unknown";
+                        const summaries = yield (0, llm_client_1.summarizeChunks)([
+                            {
+                                code: String(r.content || ""),
+                                language: lang,
+                                file: String(r.path || ""),
+                            },
+                        ]);
+                        if (summaries === null || summaries === void 0 ? void 0 : summaries[0]) {
+                            yield vectorDb.updateRows([id], "summary", [summaries[0]]);
+                        }
+                    }
+                }
+                catch (_a) {
+                    // Summarizer unavailable — skip
+                }
+            }))();
+        }
     });
     const onFileEvent = (event, absPath) => {
         if (closed)
@@ -304,7 +314,7 @@ function startWatcher(opts) {
     watcher.on("unlink", (p) => onFileEvent("unlink", p));
     // Periodic FTS rebuild
     const ftsInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-        if (closed)
+        if (closed || processing)
             return;
         try {
             yield vectorDb.createFTSIndex();

package/package.json

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