grepmax 0.17.21 → 0.17.22

package/dist/lib/daemon/daemon.js

@@ -62,8 +62,7 @@ const config_1 = require("../../config");
 const batch_processor_1 = require("../index/batch-processor");
 const syncer_1 = require("../index/syncer");
 const watcher_1 = require("../index/watcher");
-const searcher_1 = require("../search/searcher");
-const retriever_1 = require("../skeleton/retriever");
+const search_handler_1 = require("./search-handler");
 const meta_cache_1 = require("../store/meta-cache");
 const vector_db_1 = require("../store/vector-db");
 const process_1 = require("../utils/process");
@@ -841,105 +840,19 @@ class Daemon {
     }
     search(payload, signal) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            if (!this.vectorDb) {
-                return { ok: false, error: "daemon not ready" };
-            }
-            const root = payload.projectRoot;
-            if (!this.processors.has(root)) {
-                // A full index (--reset) or the initial index removes/defers the
-                // processor while (re)building. The partial index is still queryable, so
-                // answer the search and flag it partial (below) rather than erroring —
-                // only truly-unwatched, not-indexing projects get "not watched".
-                const indexingNow = this.indexProgress.has(root) || ((_a = (0, project_registry_1.getProject)(root)) === null || _a === void 0 ? void 0 : _a.status) === "pending";
-                if (!indexingNow) {
-                    return {
-                        ok: false,
-                        error: "project not watched",
-                        hint: `run: gmax add ${root}`,
-                    };
-                }
-            }
-            let searcher = this.searchers.get(root);
-            if (!searcher) {
-                searcher = new searcher_1.Searcher(this.vectorDb);
-                this.searchers.set(root, searcher);
-            }
-            this.lastActivity = Date.now();
-            let result;
-            try {
-                result = yield searcher.search(payload.query, payload.limit, {
-                    rerank: payload.rerank === true,
-                    explain: payload.explain === true,
-                    seeds: payload.seeds,
-                }, payload.filters, payload.pathPrefix, undefined, signal);
-            }
-            catch (err) {
-                if ((err === null || err === void 0 ? void 0 : err.name) === "AbortError") {
-                    return { ok: false, error: "aborted" };
-                }
-                const msg = err instanceof Error ? err.message : String(err);
-                return { ok: false, error: "search_failed", hint: msg };
-            }
-            const response = { ok: true, data: result.data };
-            if ((_b = result.warnings) === null || _b === void 0 ? void 0 : _b.length)
-                response.warnings = result.warnings;
-            // Annotate partial results when the index is still catching up, so an
-            // agent can caveat or retry. Only attached when actually indexing (the
-            // formatter suppresses the settled case anyway).
-            const idx = this.indexState(root);
-            if (idx.indexing)
-                response.indexState = idx;
-            // --skeleton support: fetch per-file skeletons inline so the CLI doesn't
-            // have to open its own VectorDB. getStoredSkeleton is a single LIMIT-1
-            // lookup; cheap enough to call for the top N distinct paths.
-            if (payload.includeSkeletons && result.data.length > 0) {
-                const limit = payload.skeletonLimit && payload.skeletonLimit > 0 ? payload.skeletonLimit : 5;
-                const seen = new Set();
-                const skeletons = {};
-                for (const chunk of result.data) {
-                    const p = (_c = chunk.path) !== null && _c !== void 0 ? _c : (_d = chunk.metadata) === null || _d === void 0 ? void 0 : _d.path;
-                    if (!p || seen.has(p))
-                        continue;
-                    seen.add(p);
-                    if (seen.size > limit)
-                        break;
-                    try {
-                        const sk = yield (0, retriever_1.getStoredSkeleton)(this.vectorDb, p);
-                        if (sk)
-                            skeletons[p] = sk;
-                    }
-                    catch (_e) {
-                        // best-effort — drop the entry, keep the search result
-                    }
-                }
-                if (Object.keys(skeletons).length > 0)
-                    response.skeletons = skeletons;
-            }
-            // --symbol support: build a 1-hop graph using the warm vectorDb. ~5
-            // LanceDB queries; doesn't touch the worker pool.
-            if (payload.includeGraph) {
-                try {
-                    const { GraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../graph/graph-builder")));
-                    const builder = new GraphBuilder(this.vectorDb, root);
-                    response.graph = yield builder.buildGraphMultiHop(payload.query, 1);
-                }
-                catch (_f) {
-                    // best-effort — drop graph, keep results
-                }
-            }
-            // 2 MB cap on the JSON line. Lance can return huge chunks for unusual
-            // queries (very long markdown blobs). Above this we fall back to the
-            // in-process path which writes to stdout instead of a socket.
-            const serialized = JSON.stringify(response);
-            if (serialized.length > 2 * 1024 * 1024) {
-                return {
-                    ok: false,
-                    error: "oversize",
-                    hint: `${serialized.length} bytes — falling back to in-process search`,
-                };
-            }
-            return response;
+            // Search handling lives in search-handler.ts (Phase 12 split). The daemon
+            // supplies its warm VectorDB + watcher/index bookkeeping; the handler runs
+            // the query and assembles the response.
+            return (0, search_handler_1.handleDaemonSearch)({
+                vectorDb: this.vectorDb,
+                processors: this.processors,
+                indexProgress: this.indexProgress,
+                searchers: this.searchers,
+                getIndexState: (root) => this.indexState(root),
+                touchActivity: () => {
+                    this.lastActivity = Date.now();
+                },
+            }, payload, signal);
         });
     }
     listProjects() {

package/dist/lib/daemon/search-handler.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDaemonSearch = handleDaemonSearch;
+const searcher_1 = require("../search/searcher");
+const retriever_1 = require("../skeleton/retriever");
+const project_registry_1 = require("../utils/project-registry");
+/**
+ * Daemon-side search: runs the hybrid+rerank against the already-warm VectorDB
+ * and optionally attaches inline skeletons / a 1-hop graph / a partial-index
+ * footer. Extracted from Daemon.search() (Phase 12) — behavior-preserving.
+ */
+function handleDaemonSearch(deps, payload, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const { vectorDb } = deps;
+        if (!vectorDb) {
+            return { ok: false, error: "daemon not ready" };
+        }
+        const root = payload.projectRoot;
+        if (!deps.processors.has(root)) {
+            // A full index (--reset) or the initial index removes/defers the
+            // processor while (re)building. The partial index is still queryable, so
+            // answer the search and flag it partial (below) rather than erroring —
+            // only truly-unwatched, not-indexing projects get "not watched".
+            const indexingNow = deps.indexProgress.has(root) || ((_a = (0, project_registry_1.getProject)(root)) === null || _a === void 0 ? void 0 : _a.status) === "pending";
+            if (!indexingNow) {
+                return {
+                    ok: false,
+                    error: "project not watched",
+                    hint: `run: gmax add ${root}`,
+                };
+            }
+        }
+        let searcher = deps.searchers.get(root);
+        if (!searcher) {
+            searcher = new searcher_1.Searcher(vectorDb);
+            deps.searchers.set(root, searcher);
+        }
+        deps.touchActivity();
+        let result;
+        try {
+            result = yield searcher.search(payload.query, payload.limit, {
+                rerank: payload.rerank === true,
+                explain: payload.explain === true,
+                seeds: payload.seeds,
+            }, payload.filters, payload.pathPrefix, undefined, signal);
+        }
+        catch (err) {
+            if ((err === null || err === void 0 ? void 0 : err.name) === "AbortError") {
+                return { ok: false, error: "aborted" };
+            }
+            const msg = err instanceof Error ? err.message : String(err);
+            return { ok: false, error: "search_failed", hint: msg };
+        }
+        const response = { ok: true, data: result.data };
+        if ((_b = result.warnings) === null || _b === void 0 ? void 0 : _b.length)
+            response.warnings = result.warnings;
+        // Annotate partial results when the index is still catching up, so an
+        // agent can caveat or retry. Only attached when actually indexing (the
+        // formatter suppresses the settled case anyway).
+        const idx = deps.getIndexState(root);
+        if (idx.indexing)
+            response.indexState = idx;
+        // --skeleton support: fetch per-file skeletons inline so the CLI doesn't
+        // have to open its own VectorDB. getStoredSkeleton is a single LIMIT-1
+        // lookup; cheap enough to call for the top N distinct paths.
+        if (payload.includeSkeletons && result.data.length > 0) {
+            const limit = payload.skeletonLimit && payload.skeletonLimit > 0
+                ? payload.skeletonLimit
+                : 5;
+            const seen = new Set();
+            const skeletons = {};
+            for (const chunk of result.data) {
+                const p = (_c = chunk.path) !== null && _c !== void 0 ? _c : (_d = chunk.metadata) === null || _d === void 0 ? void 0 : _d.path;
+                if (!p || seen.has(p))
+                    continue;
+                seen.add(p);
+                if (seen.size > limit)
+                    break;
+                try {
+                    const sk = yield (0, retriever_1.getStoredSkeleton)(vectorDb, p);
+                    if (sk)
+                        skeletons[p] = sk;
+                }
+                catch (_e) {
+                    // best-effort — drop the entry, keep the search result
+                }
+            }
+            if (Object.keys(skeletons).length > 0)
+                response.skeletons = skeletons;
+        }
+        // --symbol support: build a 1-hop graph using the warm vectorDb. ~5
+        // LanceDB queries; doesn't touch the worker pool.
+        if (payload.includeGraph) {
+            try {
+                const { GraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../graph/graph-builder")));
+                const builder = new GraphBuilder(vectorDb, root);
+                response.graph = yield builder.buildGraphMultiHop(payload.query, 1);
+            }
+            catch (_f) {
+                // best-effort — drop graph, keep results
+            }
+        }
+        // 2 MB cap on the JSON line. Lance can return huge chunks for unusual
+        // queries (very long markdown blobs). Above this we fall back to the
+        // in-process path which writes to stdout instead of a socket.
+        const serialized = JSON.stringify(response);
+        if (serialized.length > 2 * 1024 * 1024) {
+            return {
+                ok: false,
+                error: "oversize",
+                hint: `${serialized.length} bytes — falling back to in-process search`,
+            };
+        }
+        return response;
+    });
+}

package/dist/lib/output/compact-results.js

@@ -0,0 +1,244 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTextResults = toTextResults;
+exports.toCompactHits = toCompactHits;
+exports.formatCompactTable = formatCompactTable;
+exports.resultCountHeader = resultCountHeader;
+const path = __importStar(require("node:path"));
+function toTextResults(data) {
+    return data.map((r) => {
+        var _a, _b, _c, _d, _e, _f;
+        const rawPath = typeof ((_a = r.metadata) === null || _a === void 0 ? void 0 : _a.path) === "string"
+            ? r.metadata.path
+            : "Unknown path";
+        const start = typeof ((_b = r.generated_metadata) === null || _b === void 0 ? void 0 : _b.start_line) === "number"
+            ? r.generated_metadata.start_line
+            : 0;
+        const end = typeof ((_c = r.generated_metadata) === null || _c === void 0 ? void 0 : _c.end_line) === "number"
+            ? r.generated_metadata.end_line
+            : start + Math.max(0, ((_e = (_d = r.generated_metadata) === null || _d === void 0 ? void 0 : _d.num_lines) !== null && _e !== void 0 ? _e : 1) - 1);
+        return {
+            path: rawPath,
+            score: r.score,
+            content: r.text || "",
+            chunk_type: (_f = r.generated_metadata) === null || _f === void 0 ? void 0 : _f.type,
+            start_line: start,
+            end_line: end,
+        };
+    });
+}
+function getPreviewText(chunk) {
+    var _a, _b, _c, _d, _e;
+    const maxLen = 140;
+    const lines = (_b = (_a = chunk.text) === null || _a === void 0 ? void 0 : _a.split("\n").map((l) => l.trim()).filter(Boolean)) !== null && _b !== void 0 ? _b : [];
+    let preview = (_c = lines[0]) !== null && _c !== void 0 ? _c : "";
+    if (!preview && ((_d = chunk.defined_symbols) === null || _d === void 0 ? void 0 : _d.length)) {
+        preview = (_e = chunk.defined_symbols[0]) !== null && _e !== void 0 ? _e : "";
+    }
+    if (preview.length > maxLen) {
+        preview = `${preview.slice(0, maxLen)}...`;
+    }
+    return preview;
+}
+function toCompactHits(data) {
+    return data.map((chunk) => {
+        var _a, _b, _c, _d, _e, _f;
+        const rawPath = typeof ((_a = chunk.metadata) === null || _a === void 0 ? void 0 : _a.path) === "string"
+            ? chunk.metadata.path
+            : "Unknown path";
+        const start = typeof ((_b = chunk.generated_metadata) === null || _b === void 0 ? void 0 : _b.start_line) === "number"
+            ? chunk.generated_metadata.start_line
+            : 0;
+        const end = typeof ((_c = chunk.generated_metadata) === null || _c === void 0 ? void 0 : _c.end_line) === "number"
+            ? chunk.generated_metadata.end_line
+            : start + Math.max(0, ((_e = (_d = chunk.generated_metadata) === null || _d === void 0 ? void 0 : _d.num_lines) !== null && _e !== void 0 ? _e : 1) - 1);
+        return {
+            path: rawPath,
+            range: `${start + 1}-${end + 1}`,
+            start_line: start,
+            end_line: end,
+            role: chunk.role,
+            confidence: chunk.confidence,
+            score: chunk.score,
+            defined: Array.isArray(chunk.defined_symbols)
+                ? chunk.defined_symbols.slice(0, 3)
+                : typeof chunk.defined_symbols === "string"
+                    ? [chunk.defined_symbols]
+                    : typeof ((_f = chunk.defined_symbols) === null || _f === void 0 ? void 0 : _f.toArray) === "function"
+                        ? chunk.defined_symbols.toArray().slice(0, 3)
+                        : [],
+            preview: getPreviewText(chunk),
+            summary: typeof chunk.summary === "string" ? chunk.summary : undefined,
+        };
+    });
+}
+function compactRole(role) {
+    if (!role)
+        return "UNK";
+    if (role.startsWith("ORCH"))
+        return "ORCH";
+    if (role.startsWith("DEF"))
+        return "DEF";
+    if (role.startsWith("IMP"))
+        return "IMPL";
+    return role.slice(0, 4).toUpperCase();
+}
+function compactConf(conf) {
+    if (!conf)
+        return "U";
+    const c = conf.toUpperCase();
+    if (c.startsWith("H"))
+        return "H";
+    if (c.startsWith("M"))
+        return "M";
+    if (c.startsWith("L"))
+        return "L";
+    return "U";
+}
+function compactScore(score) {
+    if (typeof score !== "number")
+        return "";
+    const fixed = score.toFixed(3);
+    return fixed
+        .replace(/^0\./, ".")
+        .replace(/\.?0+$/, (m) => (m.startsWith(".") ? "" : m));
+}
+function truncateEnd(s, max) {
+    if (max <= 0)
+        return "";
+    if (s.length <= max)
+        return s;
+    if (max <= 3)
+        return s.slice(0, max);
+    return `${s.slice(0, max - 3)}...`;
+}
+function padR(s, w) {
+    const n = Math.max(0, w - s.length);
+    return s + " ".repeat(n);
+}
+function padL(s, w) {
+    const n = Math.max(0, w - s.length);
+    return " ".repeat(n) + s;
+}
+function formatCompactTSV(hits, projectRoot, query) {
+    var _a, _b;
+    if (!hits.length)
+        return "No matches found.";
+    const lines = [];
+    lines.push(`gmax hits\tquery=${query}\tcount=${hits.length}`);
+    lines.push("path\tlines\tscore\trole\tconf\tdefined\tsummary");
+    for (const hit of hits) {
+        const relPath = path.isAbsolute(hit.path)
+            ? path.relative(projectRoot, hit.path)
+            : hit.path;
+        const score = compactScore(hit.score);
+        const role = compactRole(hit.role);
+        const conf = compactConf(hit.confidence);
+        const defs = ((_a = hit.defined) !== null && _a !== void 0 ? _a : []).join(",");
+        const summary = (_b = hit.summary) !== null && _b !== void 0 ? _b : "";
+        lines.push([relPath, hit.range, score, role, conf, defs, summary].join("\t"));
+    }
+    return lines.join("\n");
+}
+function formatCompactPretty(hits, projectRoot, query, termWidth, useAnsi) {
+    var _a;
+    if (!hits.length)
+        return "No matches found.";
+    const dim = (s) => (useAnsi ? `\x1b[90m${s}\x1b[0m` : s);
+    const bold = (s) => (useAnsi ? `\x1b[1m${s}\x1b[0m` : s);
+    const wLines = 9;
+    const wScore = 6;
+    const wRole = 4;
+    const wConf = 1;
+    const wDef = 20;
+    const gutters = 5;
+    const fixed = wLines + wScore + wRole + wConf + wDef + gutters;
+    const wPath = Math.max(24, Math.min(64, termWidth - fixed));
+    const header = `gmax hits  count=${hits.length}  query="${query}"`;
+    const cols = [
+        padR("path", wPath),
+        padR("lines", wLines),
+        padL("score", wScore),
+        padR("role", wRole),
+        padR("c", wConf),
+        padR("defined", wDef),
+    ].join(" ");
+    const out = [];
+    out.push(bold(header));
+    out.push(dim(cols));
+    for (const hit of hits) {
+        const relPath = path.isAbsolute(hit.path)
+            ? path.relative(projectRoot, hit.path)
+            : hit.path;
+        const score = compactScore(hit.score);
+        const role = compactRole(hit.role);
+        const conf = compactConf(hit.confidence);
+        const defs = ((_a = hit.defined) !== null && _a !== void 0 ? _a : []).join(",") || "-";
+        const displayPath = `${relPath}:${hit.start_line + 1}`;
+        const paddedPath = padR(displayPath, wPath);
+        const row = [
+            paddedPath,
+            padR(hit.range, wLines),
+            padL(score || "", wScore),
+            padR(role, wRole),
+            padR(conf, wConf),
+            padR(truncateEnd(defs, wDef), wDef),
+        ].join(" ");
+        out.push(row);
+    }
+    return out.join("\n");
+}
+function formatCompactTable(hits, projectRoot, query, opts) {
+    var _a;
+    if (!hits.length)
+        return "No matches found.";
+    if (!opts.isTTY || opts.plain) {
+        return formatCompactTSV(hits, projectRoot, query);
+    }
+    const termWidth = Math.max(80, (_a = process.stdout.columns) !== null && _a !== void 0 ? _a : 120);
+    return formatCompactPretty(hits, projectRoot, query, termWidth, true);
+}
+function resultCountHeader(results, maxCount) {
+    var _a, _b, _c;
+    const files = new Set();
+    for (const r of results) {
+        const p = (_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 : "";
+        if (p)
+            files.add(p);
+    }
+    const showing = results.length < maxCount ? `${results.length}` : `top ${results.length}`;
+    return `Found ${results.length} match${results.length === 1 ? "" : "es"} (showing ${showing}) across ${files.size} file${files.size === 1 ? "" : "s"}`;
+}

package/package.json

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