grepmax 0.26.2 → 0.26.4

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

package/dist/commands/context.js

@@ -45,7 +45,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.context = void 0;
 exports.findEnclosingSignature = findEnclosingSignature;
 const fs = __importStar(require("node:fs"));
-const path = __importStar(require("node:path"));
 const commander_1 = require("commander");
 const searcher_1 = require("../lib/search/searcher");
 const skeleton_1 = require("../lib/skeleton");
@@ -102,20 +101,6 @@ function findEnclosingSignature(lines, startLine, parentSymbol) {
     }
     return null;
 }
-function resolveExistingPath(target, root, projectRoot) {
-    const candidates = [
-        path.isAbsolute(target) ? target : path.resolve(root, target),
-        path.resolve(projectRoot, target),
-    ];
-    for (const candidate of candidates) {
-        if (!fs.existsSync(candidate))
-            continue;
-        return (0, path_containment_1.resolveContainedPath)(projectRoot, candidate, {
-            verifyExistingTarget: true,
-        });
-    }
-    return null;
-}
 function renderPathContext(target, absPath, projectRoot, budget) {
     return __awaiter(this, void 0, void 0, function* () {
         const state = {
@@ -192,7 +177,10 @@ exports.context = new commander_1.Command("context")
         const projectRoot = (_a = (0, project_root_1.findProjectRoot)(root)) !== null && _a !== void 0 ? _a : root;
         const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
         vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
-        const pathTarget = resolveExistingPath(topic, root, projectRoot);
+        const pathTarget = (0, path_containment_1.resolveContainedExistingPath)(projectRoot, topic, {
+            cwd: root,
+            onOutside: "throw",
+        });
         if (pathTarget) {
             const rendered = yield renderPathContext(topic, pathTarget, projectRoot, budget);
             rendered.sections.push(`\n(~${rendered.tokensUsed}/${budget} tokens used)`);

package/dist/commands/related.js

@@ -50,6 +50,7 @@ const agent_errors_1 = require("../lib/utils/agent-errors");
 const arrow_1 = require("../lib/utils/arrow");
 const exit_1 = require("../lib/utils/exit");
 const filter_builder_1 = require("../lib/utils/filter-builder");
+const path_containment_1 = require("../lib/utils/path-containment");
 const project_registry_1 = require("../lib/utils/project-registry");
 const project_root_1 = require("../lib/utils/project-root");
 const query_timeout_1 = require("../lib/utils/query-timeout");
@@ -63,7 +64,7 @@ exports.related = new commander_1.Command("related")
     .option("--exclude <subpath>", "Exclude a sub-path of the project (repeatable)", (value, prev) => prev ? [...prev, value] : [value])
     .option("--agent", "Compact output for AI agents", false)
     .action((file, opts) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+    var _a, _b;
     const limit = Math.min(Math.max(Number.parseInt(opts.limit || "10", 10), 1), 25);
     let vectorDb = null;
     try {
@@ -75,7 +76,7 @@ exports.related = new commander_1.Command("related")
         (0, stale_hint_1.maybeWarnStaleEmbedding)(projectRoot, { agent: opts.agent });
         const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
         vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
-        const absPath = path.resolve(projectRoot, file);
+        const absPath = (_b = (0, path_containment_1.resolveContainedExistingPath)(projectRoot, file)) !== null && _b !== void 0 ? _b : path.resolve(projectRoot, file);
         const table = yield vectorDb.ensureTable();
         const { resolveScope, buildScopeWhere } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/scope-filter")));
         const scope = resolveScope({
@@ -267,7 +268,7 @@ exports.related = new commander_1.Command("related")
             try {
                 yield vectorDb.close();
             }
-            catch (_b) { }
+            catch (_c) { }
         }
         yield (0, exit_1.gracefulExit)();
     }

package/dist/commands/search.js

@@ -43,10 +43,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.search = void 0;
+const path = __importStar(require("node:path"));
 const commander_1 = require("commander");
 const setup_helpers_1 = require("../lib/setup/setup-helpers");
 const cross_project_1 = require("../lib/utils/cross-project");
 const exit_1 = require("../lib/utils/exit");
+const path_containment_1 = require("../lib/utils/path-containment");
 const project_registry_1 = require("../lib/utils/project-registry");
 const project_root_1 = require("../lib/utils/project-root");
 const scope_filter_1 = require("../lib/utils/scope-filter");
@@ -99,7 +101,7 @@ Examples:
   gmax "auth middleware" --projects api,gateway --plain
 `)
     .action((pattern, exec_path, _options, cmd) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     const options = cmd.optsWithGlobals();
     const root = process.cwd();
     const minScore = Number.isFinite(Number.parseFloat(options.minScore))
@@ -161,6 +163,17 @@ Examples:
     }
     const cwdProjectRoot = (_d = (0, project_root_1.findProjectRoot)(root)) !== null && _d !== void 0 ? _d : root;
     const projectRootForServer = resolvedOptionRoot !== null && resolvedOptionRoot !== void 0 ? resolvedOptionRoot : cwdProjectRoot;
+    // A cwd inside a nested git repo covered by a registered umbrella project
+    // resolves to the umbrella (findProjectRoot). Scope the search to the
+    // subrepo and resolve relative subpaths against it — that's what a caller
+    // inside the subrepo means by "this project". --root overrides this.
+    const cwdGitRoot = crossProject.active ? null : (0, project_root_1.findGitRoot)(root);
+    const nestedScopeRoot = !options.root &&
+        cwdGitRoot &&
+        cwdGitRoot !== cwdProjectRoot &&
+        (0, path_containment_1.isPathWithin)(cwdProjectRoot, cwdGitRoot)
+        ? cwdGitRoot
+        : undefined;
     if (exec_path && options.in && options.in.length > 0) {
         console.warn("Warning: --in overrides positional [path]; using --in.");
     }
@@ -168,11 +181,14 @@ Examples:
     try {
         scope = (0, scope_filter_1.resolveScope)({
             projectRoot: projectRootForServer,
+            base: nestedScopeRoot,
             in: options.in && options.in.length > 0
                 ? options.in
                 : exec_path
                     ? [exec_path]
-                    : undefined,
+                    : nestedScopeRoot
+                        ? [nestedScopeRoot]
+                        : undefined,
             exclude: options.exclude,
         });
     }
@@ -182,6 +198,13 @@ Examples:
         yield (0, exit_1.gracefulExit)(1);
         return;
     }
+    // Only announce the scope when it was implied by the cwd; an explicit
+    // --in/[path] already states what the caller scoped to.
+    if (nestedScopeRoot && !((_e = options.in) === null || _e === void 0 ? void 0 : _e.length) && !exec_path) {
+        const subName = path.relative(cwdProjectRoot, nestedScopeRoot);
+        const projName = path.basename(cwdProjectRoot);
+        console.error(`Scoped to ${subName}/ within ${projName}; pass --root ${projName} to search the whole project.`);
+    }
     const containedExecPath = exec_path && !(options.in && options.in.length > 0)
         ? scope.pathPrefix.replace(/\/$/, "")
         : undefined;
@@ -212,7 +235,7 @@ Examples:
                 : (0, project_registry_1.resolveRootOrExit)(options.root);
             if (resolved === null)
                 return;
-            checkRoot = (_e = (0, project_root_1.findProjectRoot)(resolved)) !== null && _e !== void 0 ? _e : resolved;
+            checkRoot = (_f = (0, project_root_1.findProjectRoot)(resolved)) !== null && _f !== void 0 ? _f : resolved;
         }
         const projectRoot = crossProject.active ? cwdProjectRoot : checkRoot;
         const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
@@ -320,13 +343,13 @@ Examples:
                 source: "cli",
                 tool: "search",
                 query: pattern,
-                project: (_f = (0, project_root_1.findProjectRoot)(root)) !== null && _f !== void 0 ? _f : root,
+                project: (_g = (0, project_root_1.findProjectRoot)(root)) !== null && _g !== void 0 ? _g : root,
                 results: _searchResultCount,
                 ms: Date.now() - _searchStartMs,
                 error: _searchError,
             });
         }
-        catch (_g) { }
+        catch (_h) { }
         if (vectorDb) {
             try {
                 yield vectorDb.close();

package/dist/commands/skeleton.js

@@ -128,7 +128,7 @@ Examples:
   gmax skeleton "auth logic"     Search, skeletonize top matches
 `)
     .action((target, options, _cmd) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
+    var _a, _b, _c, _d, _e;
     let vectorDb = null;
     try {
         // Initialize
@@ -166,8 +166,10 @@ Examples:
         const skeletonOpts = {
             includeSummary: !options.noSummary,
         };
-        // Determine mode based on target
-        const resolvedTarget = (0, path_containment_1.resolveContainedPath)(projectRoot, target, {
+        // Determine mode based on target. Prefer an existing cwd-relative
+        // match so callers inside a subdirectory (or nested subrepo) can pass
+        // paths relative to where they are.
+        const resolvedTarget = (_b = (0, path_containment_1.resolveContainedExistingPath)(projectRoot, target)) !== null && _b !== void 0 ? _b : (0, path_containment_1.resolveContainedPath)(projectRoot, target, {
             verifyExistingTarget: true,
         });
         // Directory mode is unsupported. Auto-picking files from a directory
@@ -191,7 +193,7 @@ Examples:
                 .map((t) => t.trim())
                 .filter(Boolean);
             for (const t of targets) {
-                const filePath = (0, path_containment_1.resolveContainedPath)(projectRoot, t, {
+                const filePath = (_c = (0, path_containment_1.resolveContainedExistingPath)(projectRoot, t)) !== null && _c !== void 0 ? _c : (0, path_containment_1.resolveContainedPath)(projectRoot, t, {
                     verifyExistingTarget: true,
                 });
                 if (!fs.existsSync(filePath)) {
@@ -206,7 +208,7 @@ Examples:
         }
         if (isFilePath(target)) {
             // === FILE MODE ===
-            const filePath = (0, path_containment_1.resolveContainedPath)(projectRoot, target, {
+            const filePath = (_d = (0, path_containment_1.resolveContainedExistingPath)(projectRoot, target)) !== null && _d !== void 0 ? _d : (0, path_containment_1.resolveContainedPath)(projectRoot, target, {
                 verifyExistingTarget: true,
             });
             if (!fs.existsSync(filePath)) {
@@ -275,7 +277,7 @@ Examples:
             const seenPaths = new Set();
             const filePaths = [];
             for (const result of searchResults.data) {
-                const resultPath = (_b = result.metadata) === null || _b === void 0 ? void 0 : _b.path;
+                const resultPath = (_e = result.metadata) === null || _e === void 0 ? void 0 : _e.path;
                 if (resultPath && !seenPaths.has(resultPath)) {
                     seenPaths.add(resultPath);
                     filePaths.push(resultPath);
@@ -293,7 +295,7 @@ Examples:
                         verifyExistingTarget: true,
                     });
                 }
-                catch (_c) {
+                catch (_f) {
                     results.push({
                         file: filePath,
                         skeleton: `// File outside selected project: ${filePath}`,
@@ -352,7 +354,7 @@ Examples:
             try {
                 yield vectorDb.close();
             }
-            catch (_d) {
+            catch (_g) {
                 // Ignore close errors
             }
         }

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

@@ -121,12 +121,14 @@ class WatcherManager {
             try {
                 const filePolicy = new file_policy_1.ProjectFilePolicy(root);
                 let processor;
+                let lastReindexAt;
                 processor = new batch_processor_1.ProjectBatchProcessor(Object.assign(Object.assign({ projectRoot: root, vectorDb,
                     metaCache }, (workerPool ? { workerPool } : {})), { filePolicy, onPolicyChange: () => {
                         void this.runCatchup(root, processor).catch((err) => {
                             console.error(`[daemon:${path.basename(root)}] Policy reconciliation failed:`, err);
                         });
                     }, onReindex: (files, ms) => __awaiter(this, void 0, void 0, function* () {
+                        lastReindexAt = Date.now();
                         console.log(`[daemon:${path.basename(root)}] Reindexed ${files} file${files !== 1 ? "s" : ""} (${(ms / 1000).toFixed(1)}s)`);
                         // Update project registry so gmax status shows fresh data
                         const proj = (0, project_registry_1.getProject)(root);
@@ -140,16 +142,13 @@ class WatcherManager {
                             }
                             (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { lastIndexed: new Date().toISOString(), chunkCount }));
                         }
-                        // Back to watching after batch completes
-                        (0, watcher_store_1.registerWatcher)({
-                            pid: process.pid,
-                            projectRoot: root,
-                            startTime: Date.now(),
-                            status: this.isRootDegraded(root) ? "degraded" : "watching",
-                            lastHeartbeat: Date.now(),
-                            lastReindex: Date.now(),
-                        });
-                    }), onActivity: () => {
+                    }), onBatchSettled: () => {
+                        (0, watcher_store_1.registerWatcher)(Object.assign({ pid: process.pid, projectRoot: root, startTime: Date.now(), status: this.isRootDegraded(root)
+                                ? "degraded"
+                                : processor.progress.pendingFiles > 0
+                                    ? "syncing"
+                                    : "watching", lastHeartbeat: Date.now() }, (lastReindexAt ? { lastReindex: lastReindexAt } : {})));
+                    }, onActivity: () => {
                         this.deps.touchActivity();
                         // Mark as syncing while processing
                         (0, watcher_store_1.registerWatcher)({

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

@@ -78,6 +78,7 @@ class ProjectBatchProcessor {
         this.workerPool = (_a = opts.workerPool) !== null && _a !== void 0 ? _a : (0, pool_1.getWorkerPool)();
         this.onReindex = opts.onReindex;
         this.onActivity = opts.onActivity;
+        this.onBatchSettled = opts.onBatchSettled;
         this.onPolicyChange = opts.onPolicyChange;
         this.onTerminalFailure = opts.onTerminalFailure;
         this.onPathSuccess = opts.onPathSuccess;
@@ -190,7 +191,7 @@ class ProjectBatchProcessor {
     }
     processBatch(operationSignal) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c, _d, _e, _f;
             if (this.closed || this.processing || this.pending.size === 0)
                 return;
             const diskPressure = this.vectorDb.checkDiskPressure();
@@ -574,6 +575,8 @@ class ProjectBatchProcessor {
                         this.schedulePendingBatch();
                     }
                 }
+                if (!this.closed)
+                    (_f = this.onBatchSettled) === null || _f === void 0 ? void 0 : _f.call(this);
             }
         });
     }

package/dist/lib/index/watcher.js

@@ -195,6 +195,7 @@ function startWatcher(opts) {
         processor = new batch_processor_1.ProjectBatchProcessor(Object.assign(Object.assign({}, opts), { filePolicy, onPolicyChange: reconcile, onReindex: (files, durationMs) => {
                 var _a;
                 (_a = opts.onReindex) === null || _a === void 0 ? void 0 : _a.call(opts, files, durationMs);
+            }, onBatchSettled: () => {
                 reportHealthyIfSettled();
             }, onTerminalFailure: (absPath) => {
                 var _a;

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

@@ -96,6 +96,10 @@ class VectorDB {
         this.maintenancePromise = null;
         this.maintenanceTimer = null;
         this.maintenanceRunner = (fn) => fn();
+        /** Latched when a from-scratch FTS rebuild failed to stop an optimize
+         *  panic. Stops the (expensive) rebuild from re-running every maintenance
+         *  tick for a panic it cannot fix; cleared when an optimize succeeds. */
+        this.ftsPanicRecoveryExhausted = false;
         this.lastCorruptionLogMs = 0;
         this.diskPressure = "ok";
         this.lastDiskCheckMs = 0;
@@ -781,6 +785,7 @@ class VectorDB {
             try {
                 const table = yield this.ensureTableUnsafe();
                 const cutoff = new Date(Date.now() - retentionMs);
+                let rebuiltFts = false;
                 for (let attempt = 1; attempt <= retries; attempt++) {
                     yield this.drainWrites();
                     try {
@@ -790,6 +795,7 @@ class VectorDB {
                             deleteUnverified: true,
                         });
                         done();
+                        this.ftsPanicRecoveryExhausted = false;
                         const { compaction, prune } = stats;
                         if (compaction.fragmentsRemoved > 0 ||
                             prune.oldVersionsRemoved > 0 ||
@@ -822,6 +828,34 @@ class VectorDB {
                             yield new Promise((r) => setTimeout(r, delay));
                             continue;
                         }
+                        // A Rust panic here is the lance-index inverted (FTS) merge bug
+                        // (out-of-bounds in scalar/inverted/builder.rs): the incremental
+                        // merge trips on inconsistent index state, and because optimize()
+                        // is all-or-nothing it blocks compaction and pruning entirely.
+                        // Rebuild the FTS index from scratch once and retry. Must use the
+                        // Unsafe variant: the public createFTSIndex waits on
+                        // compactingPromise, which we hold.
+                        if (msg.includes("Panic")) {
+                            if (attempt < retries &&
+                                !rebuiltFts &&
+                                !this.ftsPanicRecoveryExhausted) {
+                                rebuiltFts = true;
+                                (0, logger_1.log)("vectordb", "Optimize panicked (likely corrupt FTS merge) — rebuilding FTS index from scratch and retrying");
+                                try {
+                                    yield this.createFTSIndexUnsafe(true);
+                                    continue;
+                                }
+                                catch (rebuildErr) {
+                                    this.ftsPanicRecoveryExhausted = true;
+                                    (0, logger_1.log)("vectordb", `FTS rebuild failed: ${rebuildErr}`);
+                                    return;
+                                }
+                            }
+                            if (rebuiltFts) {
+                                this.ftsPanicRecoveryExhausted = true;
+                                (0, logger_1.log)("vectordb", "Optimize still panicking after FTS rebuild — disabling auto-rebuild until an optimize succeeds");
+                            }
+                        }
                         (0, logger_1.log)("vectordb", `Optimize failed: ${msg}`);
                         return;
                     }

package/dist/lib/utils/path-containment.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PathContainmentError = void 0;
 exports.isPathWithin = isPathWithin;
 exports.resolveContainedPath = resolveContainedPath;
+exports.resolveContainedExistingPath = resolveContainedExistingPath;
 exports.resolveContainedFile = resolveContainedFile;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -92,6 +93,43 @@ function resolveContainedPath(root, input, options = {}) {
     }
     return candidate;
 }
+/**
+ * Resolve a target that may be cwd-relative or root-relative, preferring an
+ * existing cwd-relative match — what a caller sitting in a subdirectory (or
+ * a nested subrepo of an umbrella project) means by the path. A candidate
+ * that exists but lies outside the root is skipped so the root-relative
+ * interpretation can still win. Returns null when no contained candidate
+ * exists; with onOutside: "throw", an existing-but-outside match raises
+ * PathContainmentError instead (for callers that must loudly reject it).
+ */
+function resolveContainedExistingPath(root, target, options = {}) {
+    var _a;
+    const cwd = (_a = options.cwd) !== null && _a !== void 0 ? _a : process.cwd();
+    const candidates = [
+        path.isAbsolute(target) ? path.resolve(target) : path.resolve(cwd, target),
+        path.resolve(root, target),
+    ];
+    let outside = null;
+    for (const candidate of candidates) {
+        if (!fs.existsSync(candidate))
+            continue;
+        try {
+            return resolveContainedPath(root, candidate, {
+                verifyExistingTarget: true,
+            });
+        }
+        catch (err) {
+            if (err instanceof PathContainmentError) {
+                outside !== null && outside !== void 0 ? outside : (outside = err);
+                continue;
+            }
+            throw err;
+        }
+    }
+    if (options.onOutside === "throw" && outside)
+        throw outside;
+    return null;
+}
 /** Resolve an existing regular file and return its canonical, contained path. */
 function resolveContainedFile(root, input) {
     const candidate = resolveContainedPath(root, input);

package/dist/lib/utils/project-root.js

@@ -33,30 +33,61 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.findGitRoot = findGitRoot;
 exports.findProjectRoot = findProjectRoot;
 exports.ensureProjectPaths = ensureProjectPaths;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
+const path_containment_1 = require("./path-containment");
+const project_registry_1 = require("./project-registry");
 /**
- * Find the project root for a given directory.
- * Looks for .git to determine the project boundary.
- * Falls back to the directory itself if no .git found.
+ * Walk up from a directory to the nearest ancestor containing .git.
+ * Returns null when no .git exists anywhere up the tree.
  */
-function findProjectRoot(startDir = process.cwd()) {
-    const start = path.resolve(startDir);
-    // Walk up to find .git
-    let dir = start;
+function findGitRoot(startDir = process.cwd()) {
+    let dir = path.resolve(startDir);
     while (true) {
         if (fs.existsSync(path.join(dir, ".git")))
             return dir;
         const parent = path.dirname(dir);
         if (parent === dir)
-            break; // reached filesystem root
+            return null; // reached filesystem root
         dir = parent;
     }
-    // No .git found — treat startDir as root
-    return start;
+}
+/**
+ * Find the project root for a given directory.
+ *
+ * The nearest .git is only a candidate boundary: a registered project may be
+ * an umbrella directory with no .git of its own whose children are separate
+ * git repos (so the .git walk lands on an unregistered subrepo), or the
+ * nearest .git may sit above the registered root (e.g. a git-tracked home
+ * dir). Resolution order:
+ *   1. the nearest .git root, when it is itself a registered project
+ *   2. the deepest registered project containing startDir
+ *   3. the nearest .git root, else startDir (unregistered fallback)
+ */
+function findProjectRoot(startDir = process.cwd()) {
+    const start = path.resolve(startDir);
+    const gitRoot = findGitRoot(start);
+    let registered = [];
+    try {
+        registered = (0, project_registry_1.listProjects)();
+    }
+    catch (_a) {
+        // A corrupt registry shouldn't break root detection; commands that need
+        // the registry surface the read error themselves.
+    }
+    const roots = registered.map((p) => path.resolve(p.root));
+    if (gitRoot && roots.includes(gitRoot))
+        return gitRoot;
+    const ancestor = roots
+        .filter((root) => (0, path_containment_1.isPathWithin)(root, start))
+        .sort((a, b) => b.length - a.length)[0];
+    if (ancestor)
+        return ancestor;
+    return gitRoot !== null && gitRoot !== void 0 ? gitRoot : start;
 }
 /**
  * Returns centralized paths for storage.

package/dist/lib/utils/scope-filter.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveScope = resolveScope;
 exports.buildScopeWhere = buildScopeWhere;
+const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const filter_builder_1 = require("./filter-builder");
 const path_containment_1 = require("./path-containment");
@@ -49,19 +50,28 @@ function toArray(value) {
         .map((v) => v.trim())
         .filter(Boolean);
 }
-function joinSubpath(projectRoot, sub) {
-    const resolved = (0, path_containment_1.resolveContainedPath)(projectRoot, sub);
+function joinSubpath(projectRoot, base, sub) {
+    let candidate = path.isAbsolute(sub) ? sub : path.resolve(base, sub);
+    if (!path.isAbsolute(sub) &&
+        path.resolve(base) !== path.resolve(projectRoot) &&
+        !fs.existsSync(candidate) &&
+        fs.existsSync(path.resolve(projectRoot, sub))) {
+        candidate = path.resolve(projectRoot, sub);
+    }
+    const resolved = (0, path_containment_1.resolveContainedPath)(projectRoot, candidate);
     return resolved.endsWith(path.sep) ? resolved : `${resolved}${path.sep}`;
 }
 function resolveScope(opts) {
+    var _a;
     const { projectRoot } = opts;
+    const base = (_a = opts.base) !== null && _a !== void 0 ? _a : projectRoot;
     const ins = toArray(opts.in);
     const excludes = toArray(opts.exclude);
     const projectPrefix = projectRoot.endsWith("/")
         ? projectRoot
         : `${projectRoot}/`;
-    const inPrefixesAll = ins.map((v) => joinSubpath(projectRoot, v));
-    const excludePrefixes = excludes.map((v) => joinSubpath(projectRoot, v));
+    const inPrefixesAll = ins.map((v) => joinSubpath(projectRoot, base, v));
+    const excludePrefixes = excludes.map((v) => joinSubpath(projectRoot, base, v));
     // Collapse a single --in into pathPrefix to keep WHERE clauses simple.
     if (inPrefixesAll.length === 1) {
         return {

package/package.json

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