grepmax 0.6.1 → 0.6.3

package/dist/commands/index.js

@@ -64,6 +64,16 @@ exports.index = new commander_1.Command("index")
     var _a;
     const options = cmd.optsWithGlobals();
     let vectorDb = null;
+    const ac = new AbortController();
+    let aborted = false;
+    const onSignal = () => {
+        if (aborted)
+            return;
+        aborted = true;
+        ac.abort();
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
     try {
         yield (0, setup_helpers_1.ensureSetup)();
         const indexRoot = options.path
@@ -107,7 +117,12 @@ exports.index = new commander_1.Command("index")
                 dryRun: options.dryRun,
                 reset: options.reset,
                 onProgress,
+                signal: ac.signal,
             });
+            if (aborted) {
+                spinner.warn(`Indexing interrupted — partial progress saved (${result.indexed} indexed)`);
+                return;
+            }
             if (options.dryRun) {
                 spinner.succeed(`Dry run complete(${result.processed} / ${result.total}) • would have indexed ${result.indexed} `);
                 console.log((0, sync_helpers_1.formatDryRunSummary)(result, {
@@ -143,6 +158,8 @@ exports.index = new commander_1.Command("index")
         process.exitCode = 1;
     }
     finally {
+        process.removeListener("SIGINT", onSignal);
+        process.removeListener("SIGTERM", onSignal);
         if (vectorDb) {
             try {
                 yield vectorDb.close();

package/dist/commands/mcp.js

@@ -338,6 +338,7 @@ exports.mcp = new commander_1.Command("mcp")
     // --- Tool handlers ---
     function handleSemanticSearch(args_1) {
         return __awaiter(this, arguments, void 0, function* (args, searchAll = false) {
+            var _a;
             const query = String(args.query || "");
             if (!query)
                 return err("Missing required parameter: query");
@@ -434,7 +435,11 @@ exports.mcp = new commander_1.Command("mcp")
                         return true;
                     });
                 }
-                return ok(results.map((r) => r.text).join("\n\n"));
+                const output = results.map((r) => r.text).join("\n\n");
+                if ((_a = result.warnings) === null || _a === void 0 ? void 0 : _a.length) {
+                    return ok(`${result.warnings.join("\n")}\n\n${output}`);
+                }
+                return ok(output);
             }
             catch (e) {
                 const msg = e instanceof Error ? e.message : String(e);

package/dist/commands/search.js

@@ -339,7 +339,7 @@ exports.search = new commander_1.Command("search")
     .argument("<pattern>", "The pattern to search for")
     .argument("[path]", "The path to search in")
     .action((pattern, exec_path, _options, cmd) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
+    var _a, _b, _c;
     const options = cmd.optsWithGlobals();
     const root = process.cwd();
     const minScore = Number.isFinite(Number.parseFloat(options.minScore))
@@ -488,6 +488,11 @@ exports.search = new commander_1.Command("search")
             ? searchPathPrefix
             : `${searchPathPrefix}/`;
         const searchResult = yield searcher.search(pattern, parseInt(options.m, 10), { rerank: true }, undefined, pathFilter);
+        if ((_c = searchResult.warnings) === null || _c === void 0 ? void 0 : _c.length) {
+            for (const w of searchResult.warnings) {
+                console.warn(`Warning: ${w}`);
+            }
+        }
         const filteredData = searchResult.data.filter((r) => typeof r.score !== "number" || r.score >= minScore);
         if (options.skeleton) {
             yield outputSkeletons(filteredData, projectRoot, parseInt(options.m, 10), vectorDb);

package/dist/commands/serve.js

@@ -426,7 +426,7 @@ exports.serve = new commander_1.Command("serve")
             });
             // Clean close of owned resources
             try {
-                metaCache.close();
+                yield metaCache.close();
             }
             catch (e) {
                 console.error("Error closing meta cache:", e);

package/dist/commands/watch.js

@@ -154,7 +154,7 @@ exports.watch = new commander_1.Command("watch")
                 yield watcher.close();
             }
             catch (_a) { }
-            metaCache.close();
+            yield metaCache.close();
             yield vectorDb.close();
             (0, watcher_registry_1.unregisterWatcher)(process.pid);
             yield (0, exit_1.gracefulExit)();

package/dist/lib/index/syncer.js

@@ -174,7 +174,7 @@ function createNoopMetaCache() {
         delete: (filePath) => {
             store.delete(filePath);
         },
-        close: () => { },
+        close: () => __awaiter(this, void 0, void 0, function* () { }),
     };
 }
 function initialSync(options) {
@@ -457,7 +457,17 @@ function initialSync(options) {
                     ? flushError
                     : new Error(String(flushError));
             }
-            if (!dryRun) {
+            // Stale cleanup: only remove paths scoped to this project's root
+            const stale = Array.from(cachedPaths).filter((p) => !seenPaths.has(p));
+            if (!dryRun && stale.length > 0 && !shouldSkipCleanup) {
+                (0, logger_1.log)("index", `Stale cleanup: ${stale.length} paths`);
+                yield vectorDb.deletePaths(stale);
+                stale.forEach((p) => {
+                    metaCache.delete(p);
+                });
+            }
+            // Only rebuild FTS index if data actually changed
+            if (!dryRun && (indexed > 0 || stale.length > 0)) {
                 const ftsTimer = (0, logger_1.timer)("index", "FTS");
                 onProgress === null || onProgress === void 0 ? void 0 : onProgress({
                     processed,
@@ -468,15 +478,6 @@ function initialSync(options) {
                 yield vectorDb.createFTSIndex();
                 ftsTimer();
             }
-            // Stale cleanup: only remove paths scoped to this project's root
-            const stale = Array.from(cachedPaths).filter((p) => !seenPaths.has(p));
-            if (!dryRun && stale.length > 0 && !shouldSkipCleanup) {
-                (0, logger_1.log)("index", `Stale cleanup: ${stale.length} paths`);
-                yield vectorDb.deletePaths(stale);
-                stale.forEach((p) => {
-                    metaCache.delete(p);
-                });
-            }
             syncTimer();
             // Write model config so future runs can detect model changes
             if (!dryRun) {
@@ -501,7 +502,7 @@ function initialSync(options) {
             if (lock) {
                 yield lock.release();
             }
-            metaCache === null || metaCache === void 0 ? void 0 : metaCache.close();
+            yield (metaCache === null || metaCache === void 0 ? void 0 : metaCache.close());
             yield vectorDb.close();
         }
     });

package/dist/lib/index/watcher.js

@@ -75,9 +75,12 @@ const FTS_REBUILD_INTERVAL_MS = 5 * 60 * 1000;
 function startWatcher(opts) {
     const { projectRoot, vectorDb, metaCache, dataDir, onReindex } = opts;
     const pending = new Map();
+    const retryCount = new Map();
     let debounceTimer = null;
     let processing = false;
     let closed = false;
+    let consecutiveLockFailures = 0;
+    const MAX_RETRIES = 5;
     const watcher = (0, chokidar_1.watch)(projectRoot, {
         ignored: exports.WATCHER_IGNORE_PATTERNS,
         ignoreInitial: true,
@@ -98,6 +101,7 @@ function startWatcher(opts) {
         debounceTimer = setTimeout(() => processBatch(), DEBOUNCE_MS);
     };
     const processBatch = () => __awaiter(this, void 0, void 0, function* () {
+        var _a;
         if (closed || processing || pending.size === 0)
             return;
         processing = true;
@@ -175,13 +179,19 @@ function startWatcher(opts) {
                         }
                     }
                 }
-                // Flush to VectorDB
-                if (deletes.length > 0) {
-                    yield vectorDb.deletePaths(deletes);
-                }
+                // Flush to VectorDB: insert first, then delete old (preserving new)
+                const newIds = vectors.map((v) => v.id);
                 if (vectors.length > 0) {
                     yield vectorDb.insertBatch(vectors);
                 }
+                if (deletes.length > 0) {
+                    if (newIds.length > 0) {
+                        yield vectorDb.deletePathsExcludingIds(deletes, newIds);
+                    }
+                    else {
+                        yield vectorDb.deletePaths(deletes);
+                    }
+                }
                 // Update MetaCache
                 for (const [p, entry] of metaUpdates) {
                     metaCache.put(p, entry);
@@ -222,7 +232,7 @@ function startWatcher(opts) {
                         }
                     }
                 }
-                catch (_a) {
+                catch (_b) {
                     // Summarizer unavailable — skip silently
                 }
             }
@@ -230,16 +240,38 @@ function startWatcher(opts) {
                 const duration = Date.now() - start;
                 onReindex === null || onReindex === void 0 ? void 0 : onReindex(reindexed, duration);
             }
+            consecutiveLockFailures = 0;
+            for (const absPath of batch.keys()) {
+                retryCount.delete(absPath);
+            }
         }
         catch (err) {
+            const isLockError = err instanceof Error && err.message.includes("lock already held");
+            if (isLockError) {
+                consecutiveLockFailures++;
+            }
             console.error("[watch] Batch processing failed:", err);
-            // Re-queue failed items for retry
+            let dropped = 0;
             for (const [absPath, event] of batch) {
-                if (!pending.has(absPath)) {
+                const count = ((_a = retryCount.get(absPath)) !== null && _a !== void 0 ? _a : 0) + 1;
+                if (count >= MAX_RETRIES) {
+                    retryCount.delete(absPath);
+                    dropped++;
+                }
+                else if (!pending.has(absPath)) {
                     pending.set(absPath, event);
+                    retryCount.set(absPath, count);
                 }
             }
-            scheduleBatch();
+            if (dropped > 0) {
+                console.warn(`[watch] Dropped ${dropped} file(s) after ${MAX_RETRIES} failed retries`);
+            }
+            if (pending.size > 0) {
+                const backoffMs = Math.min(DEBOUNCE_MS * Math.pow(2, consecutiveLockFailures), 30000);
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(() => processBatch(), backoffMs);
+            }
         }
         finally {
             processing = false;

package/dist/lib/search/searcher.js

@@ -18,6 +18,8 @@ class Searcher {
     constructor(db) {
         this.db = db;
         this.ftsIndexChecked = false;
+        this.ftsAvailable = false;
+        this.ftsLastCheckedAt = 0;
     }
     mapRecordToChunk(record, score) {
         var _a;
@@ -307,13 +309,19 @@ class Searcher {
             catch (_k) {
                 return { data: [] };
             }
-            // Ensure FTS index exists (lazy init on first search)
-            if (!this.ftsIndexChecked) {
-                this.ftsIndexChecked = true; // Set immediately to prevent retry spam
+            // Ensure FTS index exists (lazy init, retry periodically on failure)
+            const now = Date.now();
+            if (!this.ftsIndexChecked ||
+                (!this.ftsAvailable &&
+                    now - this.ftsLastCheckedAt > Searcher.FTS_RETRY_INTERVAL_MS)) {
+                this.ftsIndexChecked = true;
+                this.ftsLastCheckedAt = now;
                 try {
                     yield this.db.createFTSIndex();
+                    this.ftsAvailable = true;
                 }
                 catch (e) {
+                    this.ftsAvailable = false;
                     console.warn("[Searcher] Failed to ensure FTS index:", e);
                 }
             }
@@ -323,16 +331,21 @@ class Searcher {
             }
             const vectorResults = (yield vectorQuery.toArray());
             let ftsResults = [];
-            try {
-                let ftsQuery = table.search(query).limit(PRE_RERANK_K);
-                if (whereClause) {
-                    ftsQuery = ftsQuery.where(whereClause);
+            let ftsSearchFailed = false;
+            if (this.ftsAvailable) {
+                try {
+                    let ftsQuery = table.search(query).limit(PRE_RERANK_K);
+                    if (whereClause) {
+                        ftsQuery = ftsQuery.where(whereClause);
+                    }
+                    ftsResults = (yield ftsQuery.toArray());
+                }
+                catch (e) {
+                    ftsSearchFailed = true;
+                    this.ftsAvailable = false;
+                    const msg = e instanceof Error ? e.message : String(e);
+                    console.warn(`[Searcher] FTS search failed (will retry later): ${msg}`);
                 }
-                ftsResults = (yield ftsQuery.toArray());
-            }
-            catch (e) {
-                const msg = e instanceof Error ? e.message : String(e);
-                console.warn(`[Searcher] FTS search failed: ${msg}`);
             }
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 const err = new Error("Aborted");
@@ -453,8 +466,7 @@ class Searcher {
             const finalResults = diversified.map((item) => (Object.assign(Object.assign({}, item.record), { _score: item.score, vector: undefined, colbert: undefined })));
             // Item 12: Score Calibration
             const maxScore = finalResults.length > 0 ? finalResults[0]._score : 1.0;
-            return {
-                data: finalResults.map((r) => {
+            return Object.assign({ data: finalResults.map((r) => {
                     const chunk = this.mapRecordToChunk(r, r._score || 0);
                     // Normalize score relative to top result
                     const normalized = maxScore > 0 ? r._score / maxScore : 0;
@@ -466,9 +478,15 @@ class Searcher {
                     chunk.score = normalized;
                     chunk.confidence = confidence;
                     return chunk;
-                }),
-            };
+                }) }, (!this.ftsAvailable || ftsSearchFailed
+                ? {
+                    warnings: [
+                        "Full-text search unavailable — results may be less precise",
+                    ],
+                }
+                : {}));
         });
     }
 }
 exports.Searcher = Searcher;
+Searcher.FTS_RETRY_INTERVAL_MS = 5 * 60 * 1000;

package/dist/lib/store/meta-cache.js

@@ -156,13 +156,16 @@ class MetaCache {
         });
     }
     close() {
-        var _a;
-        if (this.closed)
-            return;
-        this.closed = true;
-        (_a = this.unregisterCleanup) === null || _a === void 0 ? void 0 : _a.call(this);
-        this.unregisterCleanup = undefined;
-        this.db.close();
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.closed)
+                return;
+            this.closed = true;
+            (_a = this.unregisterCleanup) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.unregisterCleanup = undefined;
+            yield this.db.flushed;
+            this.db.close();
+        });
     }
 }
 exports.MetaCache = MetaCache;

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

@@ -344,6 +344,25 @@ class VectorDB {
             }
         });
     }
+    deletePathsExcludingIds(paths, excludeIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!paths.length)
+                return;
+            const table = yield this.ensureTable();
+            const unique = Array.from(new Set(paths));
+            const batchSize = 500;
+            const idExclusion = excludeIds.length > 0
+                ? ` AND id NOT IN (${excludeIds.map((id) => `'${id.replace(/'/g, "''")}'`).join(",")})`
+                : "";
+            for (let i = 0; i < unique.length; i += batchSize) {
+                const slice = unique.slice(i, i + batchSize);
+                const values = slice
+                    .map((p) => `'${p.replace(/'/g, "''")}'`)
+                    .join(",");
+                yield table.delete(`path IN (${values})${idExclusion}`);
+            }
+        });
+    }
     deletePathsWithPrefix(prefix) {
         return __awaiter(this, void 0, void 0, function* () {
             const table = yield this.ensureTable();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "author": "Robert Owens <robowens@me.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -75,6 +75,9 @@
     "format": "biome check --write .",
     "format:check": "biome check .",
     "lint": "biome lint .",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "preversion": "pnpm test && pnpm typecheck",
+    "version": "bash scripts/sync-versions.sh && git add -A",
+    "postversion": "git push origin main --tags && gh release create v$npm_package_version --generate-notes --title v$npm_package_version && sleep 5 && gh run watch $(gh run list --workflow=release.yml --limit 1 --json databaseId --jq '.[0].databaseId') --exit-status && sleep 30 && npm cache clean --force && npm install -g grepmax@$npm_package_version"
   }
 }

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

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