grepmax 0.17.14 → 0.17.15

package/dist/commands/search.js

@@ -50,6 +50,7 @@ const grammar_loader_1 = require("../lib/index/grammar-loader");
 const sync_helpers_1 = require("../lib/index/sync-helpers");
 const syncer_1 = require("../lib/index/syncer");
 const agent_search_formatter_1 = require("../lib/output/agent-search-formatter");
+const index_state_footer_1 = require("../lib/output/index-state-footer");
 const searcher_1 = require("../lib/search/searcher");
 const setup_helpers_1 = require("../lib/setup/setup-helpers");
 const skeleton_1 = require("../lib/skeleton");
@@ -575,6 +576,7 @@ Examples:
         let searchResult = null;
         let precomputedSkeletons;
         let precomputedGraph;
+        let indexState;
         if (!options.sync && !options.dryRun) {
             try {
                 const { isDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
@@ -600,6 +602,7 @@ Examples:
                         };
                         precomputedSkeletons = resp.skeletons;
                         precomputedGraph = resp.graph;
+                        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"}`);
@@ -617,9 +620,16 @@ Examples:
         if (!searchResult) {
             vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
             // Check for active indexing lock and warn if present
-            if (!options.agent && (0, lock_1.isLocked)(paths.dataDir)) {
+            const locked = (0, lock_1.isLocked)(paths.dataDir);
+            if (!options.agent && locked) {
                 console.warn("⚠️  Warning: Indexing in progress... search results may be incomplete.");
             }
+            // No daemon here, so no precise pending count — surface the coarse
+            // signal (active lock or initial index not yet complete) so agent mode
+            // still gets a partial-index footer.
+            if (!indexState && (locked || project.status === "pending")) {
+                indexState = { indexing: true, pendingFiles: 0 };
+            }
             const hasRows = yield vectorDb.hasAnyRows();
             const needsSync = options.sync || !hasRows;
             if (needsSync) {
@@ -694,6 +704,14 @@ Examples:
                 console.warn(`Warning: ${w}`);
             }
         }
+        // Partial-index signal (Phase 6): when the index is mid-catchup, results
+        // may be incomplete. Non-agent renders it now as a warning; agent mode
+        // appends a machine-readable footer after the results below.
+        if (!options.agent) {
+            const footer = (0, index_state_footer_1.formatIndexStateFooter)(indexState, { agent: false });
+            if (footer)
+                console.warn(footer);
+        }
         let filteredData = searchResult.data.filter((r) => typeof r.score !== "number" || r.score >= minScore);
         // Post-filter by symbol name regex
         if (options.name) {
@@ -766,6 +784,12 @@ Examples:
                 }
                 catch (_1) { }
             }
+            // 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
+            // relevant files aren't indexed yet.
+            const footer = (0, index_state_footer_1.formatIndexStateFooter)(indexState, { agent: true });
+            if (footer)
+                console.log(footer);
             return;
         }
         if (options.skeleton) {

package/dist/lib/daemon/daemon.js

@@ -142,6 +142,10 @@ class Daemon {
         this.lastOverflowMs = new Map();
         this.lastCatchupEndMs = new Map();
         this.projectLocks = new Map();
+        // Full-index progress per root while initialSync runs (--reset / initial
+        // index). Presence = a full index is in flight; value drives the partial-
+        // result pending count (Phase 6). Cleared in the indexProject finally.
+        this.indexProgress = new Map();
         this.shutdownAbortControllers = new Set();
         this.llmServer = null;
         this.mlxChild = null;
@@ -809,19 +813,51 @@ class Daemon {
      * caller is responsible for binding `signal` to socket close so we abort if
      * the client disconnects mid-search.
      */
+    /**
+     * Live (re)index progress for a project: whether indexing is underway and how
+     * many files are still queued. Derived from the batch processor's pending map
+     * plus the registry's initial-index status. Cheap (in-memory) — safe to call
+     * on every search to annotate partial-result responses (Phase 6).
+     */
+    indexState(root) {
+        var _a, _b, _c;
+        const processor = this.processors.get(root);
+        const batchPending = (_a = processor === null || processor === void 0 ? void 0 : processor.progress.pendingFiles) !== null && _a !== void 0 ? _a : 0;
+        const processing = (_b = processor === null || processor === void 0 ? void 0 : processor.progress.processing) !== null && _b !== void 0 ? _b : false;
+        // status === "pending" means the initial full index hasn't completed.
+        const initialPending = ((_c = (0, project_registry_1.getProject)(root)) === null || _c === void 0 ? void 0 : _c.status) === "pending";
+        // A full index (--reset / initial) bypasses the batch processor; its
+        // onProgress feeds indexProgress, giving a real remaining count.
+        const fullIdx = this.indexProgress.get(root);
+        let pendingFiles = batchPending;
+        if (fullIdx && fullIdx.total > 0) {
+            pendingFiles = Math.max(pendingFiles, fullIdx.total - fullIdx.processed);
+        }
+        return {
+            indexing: !!fullIdx || processing || batchPending > 0 || initialPending,
+            pendingFiles,
+        };
+    }
     search(payload, signal) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             if (!this.vectorDb) {
                 return { ok: false, error: "daemon not ready" };
             }
             const root = payload.projectRoot;
             if (!this.processors.has(root)) {
-                return {
-                    ok: false,
-                    error: "project not watched",
-                    hint: `run: gmax add ${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) {
@@ -841,8 +877,14 @@ class Daemon {
                 return { ok: false, error: "search_failed", hint: msg };
             }
             const response = { ok: true, data: result.data };
-            if ((_a = result.warnings) === null || _a === void 0 ? void 0 : _a.length)
+            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.
@@ -851,7 +893,7 @@ class Daemon {
                 const seen = new Set();
                 const skeletons = {};
                 for (const chunk of result.data) {
-                    const p = (_b = chunk.path) !== null && _b !== void 0 ? _b : (_c = chunk.metadata) === null || _c === void 0 ? void 0 : _c.path;
+                    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);
@@ -862,7 +904,7 @@ class Daemon {
                         if (sk)
                             skeletons[p] = sk;
                     }
-                    catch (_d) {
+                    catch (_e) {
                         // best-effort — drop the entry, keep the search result
                     }
                 }
@@ -877,7 +919,7 @@ class Daemon {
                     const builder = new GraphBuilder(this.vectorDb, root);
                     response.graph = yield builder.buildGraphMultiHop(payload.query, 1);
                 }
-                catch (_e) {
+                catch (_f) {
                     // best-effort — drop graph, keep results
                 }
             }
@@ -1018,6 +1060,9 @@ class Daemon {
                 this.vectorDb.pauseMaintenanceLoop();
                 const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
                 let lastProgressTime = 0;
+                // Mark this root as full-indexing so concurrent searches get a
+                // partial-result footer (Phase 6); seeded at 0/0 until the first tick.
+                this.indexProgress.set(root, { processed: 0, total: 0 });
                 try {
                     const result = yield (0, syncer_1.initialSync)({
                         projectRoot: root,
@@ -1028,6 +1073,10 @@ class Daemon {
                         signal: ac.signal,
                         onProgress: (info) => {
                             this.resetActivity();
+                            this.indexProgress.set(root, {
+                                processed: info.processed,
+                                total: info.total,
+                            });
                             const now = Date.now();
                             if (now - lastProgressTime < 100)
                                 return;
@@ -1057,6 +1106,7 @@ class Daemon {
                 }
                 finally {
                     stopHeartbeat();
+                    this.indexProgress.delete(root);
                     this.shutdownAbortControllers.delete(ac);
                     (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.resumeMaintenanceLoop();
                     // Re-enable watcher (skip if shutting down)

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

@@ -96,6 +96,10 @@ class ProjectBatchProcessor {
         (_a = this.onActivity) === null || _a === void 0 ? void 0 : _a.call(this);
         this.scheduleBatch();
     }
+    /** Live (re)index progress: files queued + whether a batch is running. */
+    get progress() {
+        return { pendingFiles: this.pending.size, processing: this.processing };
+    }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;

package/dist/lib/output/index-state-footer.js

@@ -0,0 +1,29 @@
+"use strict";
+// Phase 6 — partial-index signal for agent-mode search.
+//
+// During the catchup window the index is incomplete but search still returns
+// (partial) results. Non-agent output already warns about this; agent output
+// historically did not. This formats a single machine-readable footer so an
+// agent can decide to caveat its answer or retry once indexing settles.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatIndexStateFooter = formatIndexStateFooter;
+/**
+ * One-line footer describing an in-progress index, or null when there's
+ * nothing to say (no state, or the index is settled). Suppressing the
+ * settled case keeps steady-state search silent — the footer only appears
+ * while results may actually be incomplete.
+ */
+function formatIndexStateFooter(state, opts) {
+    if (!state || !state.indexing)
+        return null;
+    const count = state.pendingFiles > 0 ? `~${state.pendingFiles} files pending` : null;
+    if (opts.agent) {
+        const parts = ["index: syncing"];
+        if (count)
+            parts.push(count);
+        parts.push("results may be incomplete — retry for full coverage");
+        return `[${parts.join(" · ")}]`;
+    }
+    const detail = count ? ` (${count})` : "";
+    return `⚠️  Index still syncing${detail} — results may be incomplete.`;
+}

package/package.json

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