grepmax 0.26.23 → 0.26.26

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.23",
+      "version": "0.26.26",
       "author": {
         "name": "Robert Owens",
         "email": "robowens@me.com"

package/dist/lib/daemon/watcher-manager.js

@@ -62,8 +62,16 @@ const logger_1 = require("../utils/logger");
 const project_registry_1 = require("../utils/project-registry");
 const watcher_store_1 = require("../utils/watcher-store");
 // Watcher health windows used for FSEvents auto-recovery.
-const FSEVENTS_RECOVERY_INTERVAL_MS = 60 * 60 * 1000; // try recovery hourly
+// Poll mode is the expensive state (a full catchup scan every 5 min), and in
+// practice the first reattach attempt succeeds once the burst that caused the
+// overflows has passed. Probe often; a failed probe just drops back to polling.
+const FSEVENTS_RECOVERY_INTERVAL_MS = 15 * 60 * 1000;
 const FSEVENTS_HEALTH_WINDOW_MS = 5 * 60 * 1000; // 5 min of quiet = "healthy"
+// Overflows arrive in bursts (a build, a checkout, a venv install). Every
+// recovery inside this window folds into one deferred catchup scan instead of
+// each rescanning the project (~25s on a 26k-file tree) or skipping outright
+// and leaving its drop window uncovered.
+const CATCHUP_COOLDOWN_MS = 5 * 60 * 1000;
 function abortableDelay(ms, signal) {
     if (signal.aborted)
         return Promise.resolve();
@@ -97,6 +105,7 @@ class WatcherManager {
         this.recoveryTimeouts = new Map();
         this.lastOverflowMs = new Map();
         this.lastCatchupEndMs = new Map();
+        this.deferredCatchups = new Map();
         this.catchups = new Map();
         this.degradedRoots = new Set();
         this.terminalFailures = new Map();
@@ -354,10 +363,12 @@ class WatcherManager {
                     yield this.subscribeWatcher(root, processor);
                     if (this.deps.processors.get(root) !== processor)
                         return;
-                    const lastCatchup = (_a = this.lastCatchupEndMs.get(root)) !== null && _a !== void 0 ? _a : 0;
-                    const CATCHUP_COOLDOWN_MS = 60000;
-                    if (Date.now() - lastCatchup < CATCHUP_COOLDOWN_MS) {
-                        console.log(`[daemon:${name}] Skipping catchup scan (last completed ${Math.round((Date.now() - lastCatchup) / 1000)}s ago)`);
+                    const sinceLastMs = Date.now() - ((_a = this.lastCatchupEndMs.get(root)) !== null && _a !== void 0 ? _a : 0);
+                    if (sinceLastMs < CATCHUP_COOLDOWN_MS) {
+                        const delayMs = CATCHUP_COOLDOWN_MS - sinceLastMs;
+                        if (this.deferCatchup(root, processor, delayMs)) {
+                            console.log(`[daemon:${name}] Deferring catchup scan (last completed ${Math.round(sinceLastMs / 1000)}s ago; one coalesced scan in ${Math.round(delayMs / 1000)}s)`);
+                        }
                     }
                     else {
                         yield this.runCatchup(root, processor);
@@ -374,6 +385,34 @@ class WatcherManager {
         }, delayMs);
         this.recoveryTimeouts.set(root, timeout);
     }
+    /**
+     * Schedule one catchup scan for the root at the end of the cooldown. Returns
+     * false when a deferred scan is already pending — every overflow inside the
+     * window is covered by that single scan, since it walks the whole project.
+     */
+    deferCatchup(root, processor, delayMs) {
+        if (this.deferredCatchups.has(root))
+            return false;
+        const name = path.basename(root);
+        const timer = setTimeout(() => {
+            this.deferredCatchups.delete(root);
+            if (this.deps.getShuttingDown() ||
+                this.deps.processors.get(root) !== processor)
+                return;
+            this.runCatchup(root, processor).catch((err) => {
+                console.error(`[daemon:${name}] Deferred catchup failed:`, err);
+            });
+        }, delayMs);
+        this.deferredCatchups.set(root, timer);
+        return true;
+    }
+    cancelDeferredCatchup(root) {
+        const timer = this.deferredCatchups.get(root);
+        if (!timer)
+            return;
+        clearTimeout(timer);
+        this.deferredCatchups.delete(root);
+    }
     /**
      * Once a project has fallen back to poll mode, periodically try to upgrade
      * back to native FSEvents. The buffer overflows that triggered the fallback
@@ -672,6 +711,7 @@ class WatcherManager {
                 clearTimeout(recoveryTimeout);
                 this.recoveryTimeouts.delete(root);
             }
+            this.cancelDeferredCatchup(root);
             this.pendingOps.delete(`recover:${root}`);
             const processor = this.deps.processors.get(root);
             this.deps.processors.delete(root);
@@ -744,6 +784,10 @@ class WatcherManager {
             for (const timeout of this.recoveryTimeouts.values()) {
                 clearTimeout(timeout);
             }
+            for (const timeout of this.deferredCatchups.values()) {
+                clearTimeout(timeout);
+            }
+            this.deferredCatchups.clear();
             this.recoveryTimeouts.clear();
             const catchups = [...this.catchups.values()];
             for (const active of catchups)

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

@@ -123,6 +123,20 @@ class ProjectBatchProcessor {
             !this.metaCache.get(normalized) &&
             !(event === "unlink" && (options === null || options === void 0 ? void 0 : options.forceDelete)))
             return;
+        // A policy-ignored path that was never indexed has nothing to add and
+        // nothing to delete. Drop it here rather than after a debounce, a batch
+        // slot, and an lstat — transient lock/build files under a gitignored
+        // directory can arrive thousands of times a day. Anything with a meta
+        // entry still flows through so a policy change can retire its vectors,
+        // and forced repairs/deletes bypass the check because they target
+        // vectors the meta cache may not know about.
+        const isIgnored = this.filePolicy.isIgnoredByLoadedPolicy;
+        if (isIgnored &&
+            !(options === null || options === void 0 ? void 0 : options.forceDelete) &&
+            !(options === null || options === void 0 ? void 0 : options.forceReprocess) &&
+            !this.metaCache.get(normalized) &&
+            isIgnored.call(this.filePolicy, normalized))
+            return;
         if (options === null || options === void 0 ? void 0 : options.forceReprocess) {
             this.forcedReprocess.set(normalized, ++this.forceGeneration);
         }

package/dist/lib/index/file-policy.js

@@ -66,6 +66,8 @@ class ProjectFilePolicy {
     constructor(projectRoot, options = {}) {
         var _a, _b;
         this.ignoreCache = new Map();
+        // Scopes whose ignore files have finished loading, for synchronous checks.
+        this.loadedScopes = new Map();
         this.projectRoot = path.resolve(projectRoot);
         try {
             this.canonicalRoot = fs.realpathSync(this.projectRoot);
@@ -88,6 +90,36 @@ class ProjectFilePolicy {
     }
     invalidateIgnoreCache() {
         this.ignoreCache.clear();
+        this.loadedScopes.clear();
+    }
+    /**
+     * Synchronous, best-effort ignore check against policy already in memory:
+     * the default patterns plus every .gitignore/.gmaxignore scope an earlier
+     * classify has loaded. Never touches the filesystem, so it is safe on the
+     * watcher's event path. `false` only means "not provably ignored yet" —
+     * callers must still classify before indexing.
+     */
+    isIgnoredByLoadedPolicy(absPath) {
+        const resolved = path.resolve(absPath);
+        if (!this.isLexicallyContained(resolved))
+            return true;
+        const rootRelative = this.relative(resolved);
+        if (!rootRelative)
+            return false;
+        if (this.rootFilter.ignores(rootRelative))
+            return true;
+        for (const dir of this.scopeDirectories(path.dirname(resolved))) {
+            const scope = this.loadedScopes.get(dir);
+            if (!(scope === null || scope === void 0 ? void 0 : scope.filter))
+                continue;
+            const relative = path
+                .relative(scope.dir, resolved)
+                .split(path.sep)
+                .join("/");
+            if (relative && scope.filter.ignores(relative))
+                return true;
+        }
+        return false;
     }
     isLexicallyContained(absPath) {
         return (0, path_containment_1.isPathWithin)(this.projectRoot, path.resolve(absPath));
@@ -127,9 +159,14 @@ class ProjectFilePolicy {
                 return { dir, filter };
             }))();
             this.ignoreCache.set(dir, pending);
-            void pending.catch(() => {
-                if (this.ignoreCache.get(dir) === pending)
+            void pending.then((scope) => {
+                if (this.ignoreCache.get(dir) === pending) {
+                    this.loadedScopes.set(dir, scope);
+                }
+            }, () => {
+                if (this.ignoreCache.get(dir) === pending) {
                     this.ignoreCache.delete(dir);
+                }
             });
             return pending;
         });

package/dist/lib/index/ignore-patterns.js

@@ -50,6 +50,8 @@ exports.DEFAULT_IGNORE_PATTERNS = [
     "node_modules",
     "dist",
     "build",
+    ".build", // SwiftPM
+    "DerivedData", // Xcode
     "out",
     "target",
     "__pycache__",

package/dist/lib/index/watcher.js

@@ -71,6 +71,8 @@ const IGNORED_DIR_NAMES = [
     ".gmax",
     "dist",
     "build",
+    ".build", // SwiftPM
+    "DerivedData", // Xcode
     "out",
     "target",
     "__pycache__",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.23",
+  "version": "0.26.26",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -77,37 +77,37 @@
   "license": "Apache-2.0",
   "description": "Semantic code search for coding agents. Local embeddings, LLM summaries, call graph tracing.",
   "dependencies": {
-    "@clack/prompts": "^1.6.0",
+    "@clack/prompts": "^1.7.0",
     "@huggingface/transformers": "^4.2.0",
     "@lancedb/lancedb": "0.38.0-beta.3",
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@parcel/watcher": "^2.5.6",
+    "@parcel/watcher": "^2.6.0",
     "apache-arrow": "^18.1.0",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.1.11",
     "commander": "^15.0.0",
     "dotenv": "^17.4.2",
     "fast-glob": "^3.3.3",
-    "ignore": "^7.0.5",
+    "ignore": "^7.0.8",
     "lmdb": "^3.5.6",
-    "numkong": "^7.7.1",
+    "numkong": "^7.8.2",
     "onnxruntime-node": "1.24.3",
     "openai": "^6.45.0",
     "ora": "^9.4.1",
     "proper-lockfile": "^4.1.2",
-    "uuid": "^14.0.1",
+    "uuid": "^14.0.2",
     "web-tree-sitter": "^0.26.9",
-    "zod": "^4.4.3"
+    "zod": "^4.5.4"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.10",
-    "@types/node": "^26.0.1",
+    "@biomejs/biome": "2.5.11",
+    "@types/node": "^26.4.1",
     "@types/proper-lockfile": "^4.1.4",
-    "node-gyp": "^13.0.0",
+    "node-gyp": "^13.0.2",
     "ts-node": "^10.9.2",
-    "tsx": "^4.22.4",
+    "tsx": "^4.23.13",
     "typescript": "^6.0.3",
-    "vite": "^8.1.0",
-    "vitest": "^4.1.9"
+    "vite": "^8.2.2",
+    "vitest": "^4.1.11"
   }
 }

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

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