grepmax 0.17.19 → 0.17.21

package/README.md

@@ -163,6 +163,9 @@ gmax "query" [options]
 | `--explain` | Show scoring breakdown per result. | `false` |
 | `-C <n>` | Context lines before/after. | `0` |
 | `--root <dir>` | Search a different project. | cwd |
+| `--all-projects` | Search every indexed project; results grouped by project. | `false` |
+| `--projects <list>` | Search only these projects (comma-separated names). | — |
+| `--exclude-projects <list>` | With `--all-projects`, skip these projects. | — |
 | `--min-score <n>` | Minimum relevance score. | `0` |
 
 ## Background Daemon

package/dist/commands/context.js

@@ -50,6 +50,7 @@ const searcher_1 = require("../lib/search/searcher");
 const skeleton_1 = require("../lib/skeleton");
 const vector_db_1 = require("../lib/store/vector-db");
 const arrow_1 = require("../lib/utils/arrow");
+const budget_pack_1 = require("../lib/utils/budget-pack");
 const exit_1 = require("../lib/utils/exit");
 const filter_builder_1 = require("../lib/utils/filter-builder");
 const project_registry_1 = require("../lib/utils/project-registry");
@@ -157,7 +158,7 @@ exports.context = new commander_1.Command("context")
     .option("--root <dir>", "Project root directory")
     .option("--agent", "Compact output for AI agents", false)
     .action((topic, opts) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c;
     const budget = Number.parseInt(opts.budget || "4000", 10) || 4000;
     const maxResults = Number.parseInt(opts.maxResults || "10", 10) || 10;
     let vectorDb = null;
@@ -204,33 +205,45 @@ exports.context = new commander_1.Command("context")
             sections.push(epText);
             tokensUsed += estimateTokens(epText);
         }
-        // Phase 3: Key function bodies (top 2-3 results)
+        // Phase 3: Key function bodies (top 2-3 results). Token-aware packing
+        // (knapsack-continue): an oversized body is skipped so a smaller, still-
+        // relevant one can fill the remaining budget instead of aborting the rest.
         const topChunks = entryPoints.slice(0, 3);
-        const bodySection = ["\n## Key Functions"];
-        for (const r of topChunks) {
+        const bodyBlobs = topChunks.map((r) => {
+            var _a, _b;
             const absP = chunkPath(r);
             const startLine = chunkStartLine(r);
             const endLine = chunkEndLine(r);
-            const sym = (_e = (_d = (0, arrow_1.toArr)(r.defined_symbols)) === null || _d === void 0 ? void 0 : _d[0]) !== null && _e !== void 0 ? _e : "";
+            const sym = (_b = (_a = (0, arrow_1.toArr)(r.defined_symbols)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : "";
             try {
                 const content = fs.readFileSync(absP, "utf-8");
                 const allLines = content.split("\n");
                 const body = allLines
                     .slice(startLine, Math.min(endLine + 1, allLines.length))
                     .join("\n");
-                const blob = `\n--- ${relPath(projectRoot, absP)}:${startLine + 1} ${sym} ---\n${body}`;
-                const blobTokens = estimateTokens(blob);
-                if (tokensUsed + blobTokens > budget)
-                    break;
-                bodySection.push(blob);
-                tokensUsed += blobTokens;
+                return `\n--- ${relPath(projectRoot, absP)}:${startLine + 1} ${sym} ---\n${body}`;
             }
-            catch (_f) {
-                // File not readable — skip
+            catch (_c) {
+                return null; // File not readable — drop
             }
+        });
+        const bodyCandidates = bodyBlobs.map((blob, idx) => ({
+            tokens: blob ? estimateTokens(blob) : Number.POSITIVE_INFINITY,
+            score: topChunks.length - idx, // preserve relevance order
+        }));
+        const bodyPack = (0, budget_pack_1.packByBudget)(bodyCandidates, budget - tokensUsed, {
+            atLeastOne: false,
+        });
+        const bodySection = ["\n## Key Functions"];
+        for (const i of bodyPack.selected) {
+            const blob = bodyBlobs[i];
+            if (!blob)
+                continue;
+            bodySection.push(blob);
         }
         if (bodySection.length > 1) {
             sections.push(bodySection.join(""));
+            tokensUsed += bodyPack.tokensUsed;
         }
         // Phase 4: File skeletons for unique files
         const uniqueFiles = [
@@ -249,12 +262,14 @@ exports.context = new commander_1.Command("context")
                     continue;
                 const blob = `\n--- ${relPath(projectRoot, absP)} (skeleton, ~${result.tokenEstimate} tokens) ---\n${result.skeleton}`;
                 const blobTokens = estimateTokens(blob);
+                // Skip an oversized skeleton but keep trying smaller ones (a verbose
+                // file shouldn't starve the rest of the budget).
                 if (tokensUsed + blobTokens > budget)
-                    break;
+                    continue;
                 skelSection.push(blob);
                 tokensUsed += blobTokens;
             }
-            catch (_g) {
+            catch (_d) {
                 // Skip unreadable files
             }
         }
@@ -315,7 +330,7 @@ exports.context = new commander_1.Command("context")
             try {
                 yield vectorDb.close();
             }
-            catch (_h) { }
+            catch (_e) { }
         }
         yield (0, exit_1.gracefulExit)();
     }

package/dist/commands/search.js

@@ -56,6 +56,7 @@ const setup_helpers_1 = require("../lib/setup/setup-helpers");
 const skeleton_1 = require("../lib/skeleton");
 const retriever_1 = require("../lib/skeleton/retriever");
 const vector_db_1 = require("../lib/store/vector-db");
+const cross_project_1 = require("../lib/utils/cross-project");
 const exit_1 = require("../lib/utils/exit");
 const formatter_1 = require("../lib/utils/formatter");
 const import_extractor_1 = require("../lib/utils/import-extractor");
@@ -370,6 +371,9 @@ exports.search = new commander_1.Command("search")
     .option("--file <name>", "Filter to files matching this name (e.g. 'syncer.ts')")
     .option("--in <subpath>", "Restrict to a sub-path of the project (repeatable; comma-separated also accepted)", (value, prev) => prev ? [...prev, value] : [value])
     .option("--exclude <subpath>", "Exclude a sub-path of the project (repeatable; e.g. 'tests/')", (value, prev) => prev ? [...prev, value] : [value])
+    .option("--all-projects", "Search across every indexed project, not just the current one", false)
+    .option("--projects <list>", "Search only these indexed projects (comma-separated names)")
+    .option("--exclude-projects <list>", "With --all-projects, skip these projects (comma-separated names)")
     .option("--lang <ext>", "Filter by file extension (e.g. 'ts', 'py')")
     .option("--role <role>", "Filter by role: ORCHESTRATION, DEFINITION, IMPLEMENTATION")
     .option("--symbol", "Append call graph after search results", false)
@@ -389,9 +393,11 @@ Examples:
   gmax "VectorDB" --symbol --plain
   gmax "error handling" -C 5 --imports --plain
   gmax "handler" --name "handle.*" --exclude tests/
+  gmax "rate limiter" --all-projects --agent
+  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, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
     const options = cmd.optsWithGlobals();
     const root = process.cwd();
     const minScore = Number.isFinite(Number.parseFloat(options.minScore))
@@ -401,10 +407,46 @@ Examples:
     const _searchStartMs = Date.now();
     let _searchResultCount = 0;
     let _searchError;
-    // Check for running server
+    // Cross-project scope (Phase 6): --all-projects / --projects / --exclude-projects.
+    // When active, single-project path scoping is dropped in favor of the
+    // project_roots filter clauses, and results are grouped by owning project.
+    const crossProject = (0, cross_project_1.resolveCrossProjectScope)({
+        allProjects: options.allProjects,
+        projects: options.projects,
+        excludeProjects: options.excludeProjects,
+    });
+    if (crossProject.active) {
+        // These modifiers are inherently single-project (one skeleton root, one
+        // call-graph center, one budget rollup). Reject the combination up front
+        // rather than emit confusing cross-root output.
+        const conflict = options.skeleton
+            ? "--skeleton"
+            : options.contextForLlm
+                ? "--context-for-llm"
+                : options.symbol
+                    ? "--symbol"
+                    : null;
+        if (conflict) {
+            console.error(`${conflict} is single-project; drop --all-projects/--projects or ${conflict}.`);
+            process.exitCode = 1;
+            return;
+        }
+        for (const w of crossProject.warnings)
+            console.warn(`Warning: ${w}`);
+        if (!crossProject.roots.length) {
+            console.error("No matching indexed projects. Run `gmax status` to list them.");
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // Check for running server. The per-project HTTP server can't answer
+    // cross-project queries, so cross-project mode skips it and uses the
+    // daemon-mediated / in-process path (both query the shared table).
     const execPathForServer = exec_path ? path.resolve(exec_path) : root;
     const projectRootForServer = (_a = (0, project_root_1.findProjectRoot)(execPathForServer)) !== null && _a !== void 0 ? _a : execPathForServer;
-    const server = (0, server_registry_1.getServerForProject)(projectRootForServer);
+    const server = crossProject.active
+        ? null
+        : (0, server_registry_1.getServerForProject)(projectRootForServer);
     if (server) {
         try {
             const response = yield fetch(`http://localhost:${server.port}/search`, {
@@ -552,14 +594,22 @@ Examples:
             in: options.in,
             exclude: options.exclude,
         });
-        const pathFilter = options.in && options.in.length > 0
-            ? scope.pathPrefix
-            : exec_path
-                ? (() => {
-                    const p = path.resolve(exec_path);
-                    return p.endsWith("/") ? p : `${p}/`;
-                })()
-                : scope.pathPrefix;
+        // Cross-project mode drops the single-project path prefix (and any
+        // --in/[path] sub-scoping, which is meaningless across roots) in favor of
+        // the project_roots filter clauses computed below.
+        if (crossProject.active && (exec_path || ((_d = options.in) === null || _d === void 0 ? void 0 : _d.length))) {
+            console.warn("Warning: --in / [path] are single-project; ignored under --all-projects/--projects.");
+        }
+        const pathFilter = crossProject.active
+            ? undefined
+            : options.in && options.in.length > 0
+                ? scope.pathPrefix
+                : exec_path
+                    ? (() => {
+                        const p = path.resolve(exec_path);
+                        return p.endsWith("/") ? p : `${p}/`;
+                    })()
+                    : scope.pathPrefix;
         const searchFilters = {};
         if (options.file)
             searchFilters.file = options.file;
@@ -567,10 +617,19 @@ Examples:
             searchFilters.language = options.lang;
         if (options.role)
             searchFilters.role = options.role;
-        if (scope.inPrefixes.length > 0)
-            searchFilters.inPrefixes = scope.inPrefixes;
-        if (scope.excludePrefixes.length > 0)
-            searchFilters.excludePrefixes = scope.excludePrefixes;
+        if (crossProject.active) {
+            if (crossProject.projectRootsCsv)
+                searchFilters.project_roots = crossProject.projectRootsCsv;
+            if (crossProject.excludeProjectRootsCsv)
+                searchFilters.exclude_project_roots =
+                    crossProject.excludeProjectRootsCsv;
+        }
+        else {
+            if (scope.inPrefixes.length > 0)
+                searchFilters.inPrefixes = scope.inPrefixes;
+            if (scope.excludePrefixes.length > 0)
+                searchFilters.excludePrefixes = scope.excludePrefixes;
+        }
         // Aider-style seeding: --seed-file / --seed-symbol (repeatable, also
         // comma-separated) bias candidate generation toward the caller's working
         // context. Absent → undefined → inert.
@@ -621,7 +680,7 @@ Examples:
                         indexState = resp.indexState;
                     }
                     else if (process.env.GMAX_DEBUG === "1") {
-                        console.error(`[search] daemon path unavailable: ${(_d = resp.error) !== null && _d !== void 0 ? _d : "unknown"}`);
+                        console.error(`[search] daemon path unavailable: ${(_e = resp.error) !== null && _e !== void 0 ? _e : "unknown"}`);
                     }
                 }
             }
@@ -703,7 +762,7 @@ Examples:
                 }
             }
             // Ensure a watcher is running for live reindexing
-            if (!process.env.VITEST && !((_e = process.env.NODE_ENV) === null || _e === void 0 ? void 0 : _e.includes("test"))) {
+            if (!process.env.VITEST && !((_f = process.env.NODE_ENV) === null || _f === void 0 ? void 0 : _f.includes("test"))) {
                 const { launchWatcher } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/watcher-launcher")));
                 const launched = yield launchWatcher(projectRoot);
                 if (!launched.ok && launched.reason === "spawn-failed") {
@@ -715,7 +774,7 @@ Examples:
                 ? searchFilters
                 : undefined, pathFilter);
         } // end if (!searchResult) — in-process fallback
-        if (!options.agent && ((_f = searchResult.warnings) === null || _f === void 0 ? void 0 : _f.length)) {
+        if (!options.agent && ((_g = searchResult.warnings) === null || _g === void 0 ? void 0 : _g.length)) {
             for (const w of searchResult.warnings) {
                 console.warn(`Warning: ${w}`);
             }
@@ -740,7 +799,7 @@ Examples:
                     return defs.some((d) => regex.test(d));
                 });
             }
-            catch (_0) {
+            catch (_q) {
                 // Invalid regex — skip
             }
         }
@@ -757,6 +816,76 @@ Examples:
         };
         // Agent mode: ultra-compact one-line-per-result output
         _searchResultCount = filteredData.length;
+        // Cross-project (Phase 6): render grouped by owning project so idioms
+        // from different stacks don't blur into one flat list. Only the
+        // string-formatter modes reach here — skeleton/context-for-llm/symbol
+        // were rejected up front.
+        if (crossProject.active) {
+            const emitFooter = () => {
+                const footer = (0, index_state_footer_1.formatIndexStateFooter)(indexState, {
+                    agent: !!options.agent,
+                });
+                if (footer) {
+                    if (options.agent)
+                        console.log(footer);
+                    else
+                        console.warn(footer);
+                }
+            };
+            if (!filteredData.length) {
+                console.log(options.agent ? "(none)" : "No matches found.");
+                process.exitCode = 1;
+                emitFooter();
+                return;
+            }
+            const getPath = (r) => {
+                var _a, _b, _c;
+                return String((_c = (_a = r.path) !== null && _a !== void 0 ? _a : (_b = r.metadata) === null || _b === void 0 ? void 0 : _b.path) !== null && _c !== void 0 ? _c : "");
+            };
+            const groups = (0, cross_project_1.groupResultsByProject)(filteredData, crossProject.roots, getPath);
+            const isTTY = process.stdout.isTTY;
+            const shouldBePlain = options.plain || !isTTY;
+            const blocks = [];
+            for (const g of groups) {
+                let body;
+                if (options.agent) {
+                    body = (0, agent_search_formatter_1.formatAgentSearchResults)(g.items, g.root, {
+                        includeImports: options.imports,
+                        getImportsForFile,
+                        explain: options.explain,
+                    });
+                }
+                else if (options.compact) {
+                    body = formatCompactTable(toCompactHits(g.items), g.root, pattern, {
+                        isTTY: !!isTTY,
+                        plain: !!options.plain,
+                    });
+                }
+                else if (shouldBePlain) {
+                    body = (0, formatter_1.formatTextResults)(toTextResults(g.items), pattern, g.root, {
+                        isPlain: true,
+                        compact: options.compact,
+                        content: options.content,
+                        perFile: parseInt(options.perFile, 10),
+                        showScores: options.scores,
+                    });
+                }
+                else {
+                    const { formatResults } = yield Promise.resolve().then(() => __importStar(require("../lib/output/formatter")));
+                    body = formatResults(g.items, g.root, {
+                        content: options.content,
+                        explain: options.explain,
+                    });
+                }
+                const header = options.agent
+                    ? `## ${g.name} (${g.items.length})`
+                    : `=== ${g.name} (${g.items.length}) ===`;
+                blocks.push(`${header}\n${body}`);
+            }
+            console.log(blocks.join("\n\n"));
+            emitFooter();
+            return;
+        }
         if (options.agent) {
             if (!filteredData.length) {
                 console.log("(none)");
@@ -798,7 +927,7 @@ Examples:
                         }
                     }
                 }
-                catch (_1) { }
+                catch (_r) { }
             }
             // Partial-index footer last, so it's the final line the agent reads —
             // and emitted even on "(none)", where an empty result may just mean the
@@ -831,14 +960,18 @@ Examples:
         if (options.contextForLlm) {
             const fs = yield Promise.resolve().then(() => __importStar(require("node:fs")));
             const { extractImportsFromContent } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/import-extractor")));
+            const { packByBudget } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/budget-pack")));
             const budget = parseInt(options.budget, 10) || 8000;
-            let tokensUsed = 0;
-            let shown = 0;
             console.log(resultCountHeader(filteredData, parseInt(options.m, 10)));
-            for (const r of filteredData) {
-                const absP = (_j = (_g = r.path) !== null && _g !== void 0 ? _g : (_h = r.metadata) === null || _h === void 0 ? void 0 : _h.path) !== null && _j !== void 0 ? _j : "";
-                const startLine = (_o = (_l = (_k = r.startLine) !== null && _k !== void 0 ? _k : r.start_line) !== null && _l !== void 0 ? _l : (_m = r.generated_metadata) === null || _m === void 0 ? void 0 : _m.start_line) !== null && _o !== void 0 ? _o : 0;
-                const endLine = (_s = (_q = (_p = r.endLine) !== null && _p !== void 0 ? _p : r.end_line) !== null && _q !== void 0 ? _q : (_r = r.generated_metadata) === null || _r === void 0 ? void 0 : _r.end_line) !== null && _s !== void 0 ? _s : startLine;
+            // Build every candidate blob up front (token cost needs the rendered
+            // text), then pack to budget. Token-aware packing skips an oversized
+            // chunk and keeps filling with smaller, still-relevant ones rather than
+            // aborting the loop — recovering budget the old greedy `break` wasted.
+            const candidates = filteredData.map((r, idx) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+                const absP = (_c = (_a = r.path) !== null && _a !== void 0 ? _a : (_b = r.metadata) === null || _b === void 0 ? void 0 : _b.path) !== null && _c !== void 0 ? _c : "";
+                const startLine = (_g = (_e = (_d = r.startLine) !== null && _d !== void 0 ? _d : r.start_line) !== null && _e !== void 0 ? _e : (_f = r.generated_metadata) === null || _f === void 0 ? void 0 : _f.start_line) !== null && _g !== void 0 ? _g : 0;
+                const endLine = (_l = (_j = (_h = r.endLine) !== null && _h !== void 0 ? _h : r.end_line) !== null && _j !== void 0 ? _j : (_k = r.generated_metadata) === null || _k === void 0 ? void 0 : _k.end_line) !== null && _l !== void 0 ? _l : startLine;
                 const relPath = absP.startsWith(projectRoot)
                     ? absP.slice(projectRoot.length + 1)
                     : absP;
@@ -847,6 +980,7 @@ Examples:
                     r.defined_symbols.length > 0
                     ? r.defined_symbols[0]
                     : "";
+                let blobText;
                 try {
                     const content = fs.readFileSync(absP, "utf-8");
                     const allLines = content.split("\n");
@@ -857,24 +991,27 @@ Examples:
                     const blob = [
                         `--- ${relPath}:${startLine + 1}${symbol ? ` ${symbol}` : ""} [${role}] ---`,
                     ];
-                    if (imports) {
+                    if (imports)
                         blob.push("[imports]", imports, "");
-                    }
                     blob.push("[body]", body);
-                    const blobText = blob.join("\n");
-                    const blobTokens = Math.ceil(blobText.length / 4);
-                    if (tokensUsed + blobTokens > budget && shown > 0) {
-                        console.log(`\n(budget exhausted at ~${tokensUsed} tokens, ${filteredData.length - shown} more results not shown)`);
-                        break;
-                    }
-                    console.log(`\n${blobText}`);
-                    tokensUsed += blobTokens;
-                    shown++;
+                    blobText = blob.join("\n");
                 }
-                catch (_2) {
-                    console.log(`\n--- ${relPath} (file not readable) ---`);
-                    shown++;
+                catch (_m) {
+                    blobText = `--- ${relPath} (file not readable) ---`;
                 }
+                // Preserve relevance order when scores are absent (rank-derived
+                // fallback) so the density tiebreaker never reshuffles arbitrarily.
+                const score = typeof r.score === "number"
+                    ? r.score
+                    : (filteredData.length - idx) / filteredData.length;
+                return { blobText, tokens: Math.ceil(blobText.length / 4), score };
+            });
+            const pack = packByBudget(candidates.map((c) => ({ tokens: c.tokens, score: c.score })), budget);
+            for (const i of pack.selected) {
+                console.log(`\n${candidates[i].blobText}`);
+            }
+            if (pack.dropped > 0) {
+                console.log(`\n(budget: ~${pack.tokensUsed}/${budget} tokens, ${pack.dropped} lower-density result${pack.dropped > 1 ? "s" : ""} not shown)`);
             }
             return;
         }
@@ -888,7 +1025,7 @@ Examples:
         if (options.imports) {
             const seenFiles = new Set();
             for (const r of filteredData) {
-                const absP = (_v = (_t = r.path) !== null && _t !== void 0 ? _t : (_u = r.metadata) === null || _u === void 0 ? void 0 : _u.path) !== null && _v !== void 0 ? _v : "";
+                const absP = (_k = (_h = r.path) !== null && _h !== void 0 ? _h : (_j = r.metadata) === null || _j === void 0 ? void 0 : _j.path) !== null && _k !== void 0 ? _k : "";
                 if (absP && !seenFiles.has(absP)) {
                     seenFiles.add(absP);
                     const imports = getImportsForFile(absP);
@@ -915,7 +1052,7 @@ Examples:
                 for (const r of filteredData) {
                     const b = r.scoreBreakdown;
                     if (b) {
-                        const absP = (_y = (_w = r.path) !== null && _w !== void 0 ? _w : (_x = r.metadata) === null || _x === void 0 ? void 0 : _x.path) !== null && _y !== void 0 ? _y : "";
+                        const absP = (_o = (_l = r.path) !== null && _l !== void 0 ? _l : (_m = r.metadata) === null || _m === void 0 ? void 0 : _m.path) !== null && _o !== void 0 ? _o : "";
                         const relPath = absP.startsWith(projectRoot)
                             ? absP.slice(projectRoot.length + 1)
                             : absP;
@@ -977,7 +1114,7 @@ Examples:
                     console.log(lines.join("\n"));
                 }
             }
-            catch (_3) {
+            catch (_s) {
                 // Trace failed — skip silently
             }
         }
@@ -997,13 +1134,13 @@ Examples:
                 source: "cli",
                 tool: "search",
                 query: pattern,
-                project: (_z = (0, project_root_1.findProjectRoot)(root)) !== null && _z !== void 0 ? _z : root,
+                project: (_p = (0, project_root_1.findProjectRoot)(root)) !== null && _p !== void 0 ? _p : root,
                 results: _searchResultCount,
                 ms: Date.now() - _searchStartMs,
                 error: _searchError,
             });
         }
-        catch (_4) { }
+        catch (_t) { }
         if (vectorDb) {
             try {
                 yield vectorDb.close();

package/dist/lib/utils/budget-pack.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Token-aware budget packing (Phase 4).
+ *
+ * The budget-oriented output modes (`gmax context`, `gmax search
+ * --context-for-llm --budget`) greedily emit results in relevance order until
+ * the next chunk would overflow the token budget — then they STOP. That wastes
+ * the tail: a single mid-ranked verbose chunk that busts the budget aborts the
+ * whole loop, even when smaller, still-relevant chunks further down would fit.
+ *
+ * `packByBudget` fixes that with a knapsack-style greedy fill (skip the
+ * oversized chunk, keep trying the rest) plus a *conservative* density
+ * tiebreaker: among chunks whose relevance scores are within `tieEpsilon`, the
+ * denser (fewer-token) chunk is preferred. The tiebreaker only reorders
+ * near-ties, so it never buries a clearly-more-relevant chunk beneath a small
+ * tangential one. Selected items are returned in their original relevance order
+ * for display — packing is a selection concern, not a presentation one.
+ *
+ * This lives entirely in the presentation layer; it does NOT touch
+ * `searcher.ts` ranking, so search relevance / the bench are unaffected.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packByBudget = packByBudget;
+function packByBudget(candidates, budget, options = {}) {
+    var _a, _b;
+    const eps = (_a = options.tieEpsilon) !== null && _a !== void 0 ? _a : 0.02;
+    const atLeastOne = (_b = options.atLeastOne) !== null && _b !== void 0 ? _b : true;
+    if (candidates.length === 0) {
+        return { selected: [], tokensUsed: 0, dropped: 0 };
+    }
+    // Selection order: higher score first, but bucket near-ties (within eps) so
+    // the denser candidate wins inside a bucket. Bucketing keeps the comparator a
+    // valid total order (a raw |Δscore|<eps test would be intransitive).
+    const order = candidates
+        .map((c, i) => ({ i, tokens: Math.max(0, c.tokens), score: c.score }))
+        .sort((a, b) => {
+        const ba = Math.round(a.score / eps);
+        const bb = Math.round(b.score / eps);
+        if (ba !== bb)
+            return bb - ba; // higher score bucket first
+        if (a.tokens !== b.tokens)
+            return a.tokens - b.tokens; // denser first on tie
+        return a.i - b.i; // stable
+    });
+    const selected = [];
+    let used = 0;
+    for (const o of order) {
+        if (used + o.tokens > budget)
+            continue; // skip oversized, keep filling
+        selected.push(o.i);
+        used += o.tokens;
+    }
+    if (selected.length === 0 && atLeastOne) {
+        // Nothing fit — emit the single most relevant candidate anyway.
+        let best = 0;
+        for (let i = 1; i < candidates.length; i++) {
+            if (candidates[i].score > candidates[best].score)
+                best = i;
+        }
+        selected.push(best);
+        used = Math.max(0, candidates[best].tokens);
+    }
+    selected.sort((x, y) => x - y); // back to relevance/display order
+    return {
+        selected,
+        tokensUsed: used,
+        dropped: candidates.length - selected.length,
+    };
+}

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

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Cross-project search scoping (Phase 6).
+ *
+ * The shared LanceDB table holds chunks from every indexed project, scoped by
+ * absolute-path prefix. Single-project search pins a `pathPrefix`; cross-project
+ * search drops the prefix and instead scopes with the `project_roots` /
+ * `exclude_project_roots` filter clauses (an OR-group of `path LIKE` prefixes —
+ * see buildWhereClause in searcher.ts). This module resolves the CLI flags
+ * (`--all-projects` / `--projects` / `--exclude-projects`) to those filter
+ * values and groups results back by owning project for display.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCrossProjectScope = resolveCrossProjectScope;
+exports.projectForPath = projectForPath;
+exports.groupResultsByProject = groupResultsByProject;
+const project_registry_1 = require("./project-registry");
+function resolveCrossProjectScope(opts) {
+    const active = !!(opts.allProjects || opts.projects);
+    if (!active) {
+        return { active: false, roots: [], warnings: [] };
+    }
+    // Ignore "error"-status projects: the daemon won't search them anyway.
+    const all = (0, project_registry_1.listProjects)().filter((p) => p.status !== "error");
+    const byName = new Map(all.map((p) => [p.name, p]));
+    const warnings = [];
+    const resolveNames = (csv) => {
+        const names = (csv !== null && csv !== void 0 ? csv : "")
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+        const found = [];
+        const missing = [];
+        for (const n of names) {
+            const p = byName.get(n);
+            if (p)
+                found.push(p);
+            else
+                missing.push(n);
+        }
+        return { found, missing };
+    };
+    const excluded = resolveNames(opts.excludeProjects);
+    const excludedRoots = new Set(excluded.found.map((p) => p.root));
+    if (excluded.missing.length) {
+        warnings.push(`Unknown --exclude-projects: ${excluded.missing.join(", ")}`);
+    }
+    let included;
+    let projectRootsCsv;
+    let excludeProjectRootsCsv;
+    if (opts.projects) {
+        const r = resolveNames(opts.projects);
+        if (r.missing.length) {
+            warnings.push(`Unknown --projects: ${r.missing.join(", ")}. Available: ${all
+                .map((p) => p.name)
+                .join(", ")}`);
+        }
+        included = r.found.filter((p) => !excludedRoots.has(p.root));
+        // Narrowed to an explicit subset → scope with project_roots.
+        projectRootsCsv = included.length
+            ? included.map((p) => p.root).join(",")
+            : undefined;
+    }
+    else {
+        // --all-projects: search the whole shared table. No project_roots clause
+        // (its absence IS "everything"); only carve out --exclude-projects.
+        included = all.filter((p) => !excludedRoots.has(p.root));
+        if (excludedRoots.size) {
+            excludeProjectRootsCsv = [...excludedRoots].join(",");
+        }
+    }
+    return {
+        active: true,
+        roots: included.map((p) => ({ root: p.root, name: p.name })),
+        projectRootsCsv,
+        excludeProjectRootsCsv,
+        warnings,
+    };
+}
+/** Longest-prefix match of an absolute path against the in-scope project roots. */
+function projectForPath(absPath, roots) {
+    let best = null;
+    let bestLen = -1;
+    for (const r of roots) {
+        const prefix = r.root.endsWith("/") ? r.root : `${r.root}/`;
+        if (absPath === r.root || absPath.startsWith(prefix)) {
+            if (prefix.length > bestLen) {
+                best = r;
+                bestLen = prefix.length;
+            }
+        }
+    }
+    return best;
+}
+/**
+ * Bucket ranked results by owning project, preserving rank order: groups appear
+ * in order of their best-ranked member, items keep their original order.
+ */
+function groupResultsByProject(results, roots, getPath) {
+    var _a, _b, _c;
+    const order = [];
+    const buckets = new Map();
+    for (const r of results) {
+        const owner = projectForPath(getPath(r), roots);
+        const key = (_a = owner === null || owner === void 0 ? void 0 : owner.root) !== null && _a !== void 0 ? _a : "(unknown)";
+        let bucket = buckets.get(key);
+        if (!bucket) {
+            bucket = { name: (_b = owner === null || owner === void 0 ? void 0 : owner.name) !== null && _b !== void 0 ? _b : "(unknown)", root: (_c = owner === null || owner === void 0 ? void 0 : owner.root) !== null && _c !== void 0 ? _c : "", items: [] };
+            buckets.set(key, bucket);
+            order.push(key);
+        }
+        bucket.items.push(r);
+    }
+    return order.map((k) => buckets.get(k));
+}

package/package.json

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