grepmax 0.26.27 → 0.26.30

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

@@ -53,6 +53,7 @@ const logger_1 = require("../utils/logger");
 const operation_coordinator_1 = require("../utils/operation-coordinator");
 const path_containment_1 = require("../utils/path-containment");
 const project_registry_1 = require("../utils/project-registry");
+const read_verbs_1 = require("./read-verbs");
 const DAEMON_VERSION = (() => {
     try {
         return JSON.parse(fs.readFileSync(path.join(__dirname, "../../../package.json"), "utf-8")).version;
@@ -148,20 +149,29 @@ function handleCommand(daemon, cmd, conn) {
                         rebuildPending: daemon.hasUnfinishedRebuild(),
                         capabilities: {
                             exclusiveGenerationRebuild: exports.EXCLUSIVE_GENERATION_REBUILD_PROTOCOL,
+                            readVerbs: read_verbs_1.READ_VERBS_PROTOCOL,
+                            // `watch`/`unwatch` accept holder/pid/ttlMs. A daemon without this
+                            // treats `unwatch` as unwatch-for-everyone, so clients releasing a
+                            // single lease must check it first.
+                            watchLeases: 1,
                         },
                     };
                 case "watch": {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
-                    yield daemon.watchProject(root);
+                    yield daemon.requestWatch(root, {
+                        holder: typeof cmd.holder === "string" ? cmd.holder : undefined,
+                        pid: typeof cmd.pid === "number" ? cmd.pid : undefined,
+                        ttlMs: typeof cmd.ttlMs === "number" ? cmd.ttlMs : undefined,
+                    });
                     return { ok: true, pid: process.pid };
                 }
                 case "unwatch": {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
-                    yield daemon.unwatchProject(root);
+                    yield daemon.releaseWatch(root, typeof cmd.holder === "string" ? cmd.holder : undefined);
                     return { ok: true };
                 }
                 case "status":
@@ -170,6 +180,7 @@ function handleCommand(daemon, cmd, conn) {
                         pid: process.pid,
                         uptime: daemon.uptime(),
                         projects: daemon.listProjects(),
+                        leases: daemon.listWatchLeases(),
                         diskPressure: daemon.getDiskPressure(),
                         mlx: daemon.getMlxStatus(),
                     };
@@ -302,6 +313,7 @@ function handleCommand(daemon, cmd, conn) {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
+                    daemon.leaseForCli(root);
                     startStreaming(conn, () => daemon.addProject(root, conn));
                     return null;
                 }
@@ -309,6 +321,7 @@ function handleCommand(daemon, cmd, conn) {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
+                    daemon.leaseForCli(root);
                     startStreaming(conn, () => daemon.ensureProject(root, conn));
                     return null;
                 }
@@ -316,6 +329,7 @@ function handleCommand(daemon, cmd, conn) {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
+                    daemon.leaseForCli(root);
                     startStreaming(conn, () => daemon.indexProject(root, conn, {
                         reset: !!cmd.reset,
                         dryRun: !!cmd.dryRun,
@@ -373,8 +387,26 @@ function handleCommand(daemon, cmd, conn) {
                     return yield daemon.llmStop();
                 case "llm-status":
                     return daemon.llmStatus();
-                default:
-                    return { ok: false, error: `unknown command: ${cmd.cmd}` };
+                // --- Read verbs (registry in read-verbs.ts) ---
+                default: {
+                    const verb = (0, read_verbs_1.getReadVerb)(cmd.cmd);
+                    if (!verb)
+                        return { ok: false, error: `unknown command: ${cmd.cmd}` };
+                    // Same abort wiring as `search`: a client ctrl-C closes the socket,
+                    // which cancels the in-flight read instead of letting it run on.
+                    const ac = new AbortController();
+                    const onClose = () => ac.abort();
+                    conn.on("close", onClose);
+                    const name = String(cmd.cmd);
+                    try {
+                        // Heavy verbs queue on a global gate before admission; see
+                        // HEAVY_READ_VERBS in read-verbs.ts.
+                        return yield (0, read_verbs_1.runReadVerb)(name, ac.signal, () => daemon.runSharedOperation(name, ac.signal, (signal) => verb(cmd, { daemon, conn, signal })));
+                    }
+                    finally {
+                        conn.off("close", onClose);
+                    }
+                }
             }
         }
         catch (err) {

package/dist/lib/daemon/read-verbs.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * Registry for daemon read verbs.
+ *
+ * The daemon is meant to be the only process that opens the store, so every
+ * read-only CLI command becomes a thin IPC client. Rather than growing one more
+ * `case` in `ipc-handler.ts` per verb (and making that file a merge magnet),
+ * verbs register here and `ipc-handler`'s `default:` looks them up before it
+ * reports `unknown command`.
+ *
+ * Each verb runs through `Daemon.runSharedOperation(verbName, ...)`, so an
+ * exclusive rebuild answers DAEMON_BUSY naming the verb instead of racing it,
+ * and its abort signal is bound to socket close exactly like `search`.
+ *
+ * Verbs are request/response only: one JSON line in, one JSON line out. Anything
+ * that needs progress belongs in the streaming command set instead.
+ *
+ * Handlers live beside `search-handler.ts` (`graph-handler.ts`,
+ * `rows-handler.ts`, `vector-handler.ts`), each taking a narrow deps interface
+ * so `ipc-handler` tests can drive them with a fake `Daemon`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.heavyReadGate = exports.DEFAULT_HEAVY_READ_CONCURRENCY = exports.HEAVY_READ_VERBS = exports.READ_VERBS_PROTOCOL = void 0;
+exports.registerReadVerbs = registerReadVerbs;
+exports.getReadVerb = getReadVerb;
+exports.readVerbNames = readVerbNames;
+exports.resolveHeavyReadConcurrency = resolveHeavyReadConcurrency;
+exports.isHeavyReadVerb = isHeavyReadVerb;
+exports.runReadVerb = runReadVerb;
+exports.clearReadVerbs = clearReadVerbs;
+exports.registerGraphVerbs = registerGraphVerbs;
+const async_semaphore_1 = require("../utils/async-semaphore");
+const graph_handler_1 = require("./graph-handler");
+/** Bumped when the verb wire shapes change incompatibly. */
+exports.READ_VERBS_PROTOCOL = 1;
+const registry = new Map();
+/**
+ * Register one or more verbs. Re-registering a name replaces it, which keeps
+ * hot-reload and test setup simple; duplicate names across packages are a bug,
+ * so the collision is logged when it happens with a different handler.
+ */
+function registerReadVerbs(entries) {
+    const iterable = entries[Symbol.iterator];
+    const pairs = typeof iterable === "function"
+        ? entries
+        : Object.entries(entries);
+    for (const [name, handler] of pairs) {
+        registry.set(name, handler);
+    }
+}
+function getReadVerb(name) {
+    return typeof name === "string" ? registry.get(name) : undefined;
+}
+function readVerbNames() {
+    return [...registry.keys()].sort();
+}
+// ---------------------------------------------------------------------------
+// Heavy-verb admission.
+//
+// `runSharedOperation` only tracks a verb; it never limits how many run. These
+// verbs each scan a large slice of the table (tens to hundreds of thousands of
+// rows, or one vector search per sampled anchor), and their Arrow buffers sit
+// in native memory until the answer is built. With one MCP session per Claude
+// Code window, N sessions asking at once meant N such scans resident together.
+// They now share a small global semaphore; everything else stays unbounded,
+// because point lookups (`graph.resolve`, `rows.locate`, ...) are cheap and
+// must not queue behind an audit.
+//
+// A queued request waits *before* `runSharedOperation` admits it (see
+// `runReadVerb`), so an exclusive rebuild does not have to sit behind scans
+// that have not started yet, and a client that disconnects while queued
+// leaves without ever touching the store.
+// ---------------------------------------------------------------------------
+exports.HEAVY_READ_VERBS = new Set([
+    "graph.audit", // up to AUDIT_ROW_LIMIT rows with symbol arrays
+    "graph.dead", // whole caller set
+    "graph.risk", // up to MAX_RISK_SYMBOLS x three content scans
+    "graph.subgraph", // per-file symbol scans over up to MAX_SUBGRAPH_FILES
+    "graph.trace", // multi-hop caller/callee expansion
+    "rows.project", // up to 200k rows with two symbol-array columns
+    "vector.similar", // vector search plus content
+    "vector.surprises", // up to 100k-row scan plus one search per anchor
+]);
+exports.DEFAULT_HEAVY_READ_CONCURRENCY = 2;
+/** `GMAX_HEAVY_READ_CONCURRENCY`, or the default when unset or not a positive integer. */
+function resolveHeavyReadConcurrency(raw = process.env.GMAX_HEAVY_READ_CONCURRENCY) {
+    const n = Number(raw);
+    return raw !== undefined && Number.isInteger(n) && n >= 1
+        ? n
+        : exports.DEFAULT_HEAVY_READ_CONCURRENCY;
+}
+exports.heavyReadGate = new async_semaphore_1.AsyncSemaphore(resolveHeavyReadConcurrency());
+function isHeavyReadVerb(name) {
+    return typeof name === "string" && exports.HEAVY_READ_VERBS.has(name);
+}
+/**
+ * Admission wrapper `ipc-handler` puts around a verb's shared operation: heavy
+ * verbs wait for a gate slot first (abortable through `signal`), light verbs
+ * run straight through.
+ */
+function runReadVerb(name, signal, run, gate = exports.heavyReadGate) {
+    return isHeavyReadVerb(name) ? gate.run(signal, run) : run();
+}
+/** Test hook: drop every registration. */
+function clearReadVerbs() {
+    registry.clear();
+}
+// ---------------------------------------------------------------------------
+// graph verbs (WP-B) — graph.resolve, graph.tests, graph.dependents,
+// graph.trace, graph.peek, graph.dead, graph.audit; handlers in
+// graph-handler.ts.
+//
+// `graph.peek` is not in the plan's table: `peek` needs its defining-chunk rows
+// and its `is_exported`/`end_line` metadata alongside the graph, and those
+// selects would otherwise land in WP-C's `rows.locate`. Keeping them in one
+// composite verb costs one round trip instead of four and keeps peek's
+// rendering (and its `fs.readFileSync` signature extraction) unchanged.
+//
+// WP-D added four more for the MCP tools that have no CLI twin:
+// `graph.neighbors`, `graph.paths` and `graph.subgraph` are the GraphBuilder
+// traversal primitives behind `get_neighbors` / `find_paths` /
+// `subgraph_for_files` — distinct entry points with their own hop and size
+// bounds, which is why they are separate verbs rather than options on
+// `graph.trace`. `graph.risk` is the store half of `review_risk`: the git half
+// (diff, churn) stays with the caller, exactly as `extract` keeps its body read.
+// ---------------------------------------------------------------------------
+/**
+ * Called once from the Daemon constructor rather than at module load, so that
+ * importing this registry (as `ipc-handler` and its tests do) does not populate
+ * it behind a test's back.
+ */
+function registerGraphVerbs() {
+    registerReadVerbs((0, graph_handler_1.createGraphVerbs)((ctx) => ctx.daemon.storeReadDeps()));
+}
+// ---------------------------------------------------------------------------
+// rows verbs (WP-C) — rows.symbols, rows.project, rows.locate, rows.skeleton.
+// Handlers and their `registerRowsVerbs()` live in rows-handler.ts;
+// `Daemon.start()` calls it, because registering at module scope would make the
+// registry non-empty on import and break the assertions in
+// tests/ipc-read-verbs.test.ts.
+//
+// `rows.project` is not in the plan's table: `symbols` and `project` were to
+// share one row-proxy verb. `project.ts` selects up to 200 000 rows with two
+// symbol-array columns, and the platform project holds 266 753 chunks, so the
+// proxy shape would push hundreds of megabytes through the daemon's event loop
+// for a summary that fits in a few kilobytes. Both verbs return the finished
+// aggregate instead — see the rows-handler.ts header.
+//
+// WP-C also shipped `rows.tests` for `extract`'s footer; WP-D removed it. It
+// wrapped the same `findTests` call `graph.tests` does, and `extract` now sends
+// that verb, so the duplicate wire shape is gone before any daemon served it.
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// vector verbs (WP-C) — vector.similar, vector.surprises; handlers and
+// `registerVectorVerbs()` in vector-handler.ts, called from `Daemon.start()`.
+// ---------------------------------------------------------------------------