grepmax 0.17.20 → 0.17.21

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

@@ -397,7 +397,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, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
+    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))
@@ -799,7 +799,7 @@ Examples:
                     return defs.some((d) => regex.test(d));
                 });
             }
-            catch (_1) {
+            catch (_q) {
                 // Invalid regex — skip
             }
         }
@@ -927,7 +927,7 @@ Examples:
                         }
                     }
                 }
-                catch (_2) { }
+                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
@@ -960,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 = (_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 : "";
-                const startLine = (_p = (_m = (_l = r.startLine) !== null && _l !== void 0 ? _l : r.start_line) !== null && _m !== void 0 ? _m : (_o = r.generated_metadata) === null || _o === void 0 ? void 0 : _o.start_line) !== null && _p !== void 0 ? _p : 0;
-                const endLine = (_t = (_r = (_q = r.endLine) !== null && _q !== void 0 ? _q : r.end_line) !== null && _r !== void 0 ? _r : (_s = r.generated_metadata) === null || _s === void 0 ? void 0 : _s.end_line) !== null && _t !== void 0 ? _t : 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;
@@ -976,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");
@@ -986,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 (_3) {
-                    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;
         }
@@ -1017,7 +1025,7 @@ Examples:
         if (options.imports) {
             const seenFiles = new Set();
             for (const r of filteredData) {
-                const absP = (_w = (_u = r.path) !== null && _u !== void 0 ? _u : (_v = r.metadata) === null || _v === void 0 ? void 0 : _v.path) !== null && _w !== void 0 ? _w : "";
+                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);
@@ -1044,7 +1052,7 @@ Examples:
                 for (const r of filteredData) {
                     const b = r.scoreBreakdown;
                     if (b) {
-                        const absP = (_z = (_x = r.path) !== null && _x !== void 0 ? _x : (_y = r.metadata) === null || _y === void 0 ? void 0 : _y.path) !== null && _z !== void 0 ? _z : "";
+                        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;
@@ -1106,7 +1114,7 @@ Examples:
                     console.log(lines.join("\n"));
                 }
             }
-            catch (_4) {
+            catch (_s) {
                 // Trace failed — skip silently
             }
         }
@@ -1126,13 +1134,13 @@ Examples:
                 source: "cli",
                 tool: "search",
                 query: pattern,
-                project: (_0 = (0, project_root_1.findProjectRoot)(root)) !== null && _0 !== void 0 ? _0 : root,
+                project: (_p = (0, project_root_1.findProjectRoot)(root)) !== null && _p !== void 0 ? _p : root,
                 results: _searchResultCount,
                 ms: Date.now() - _searchStartMs,
                 error: _searchError,
             });
         }
-        catch (_5) { }
+        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/package.json

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