grepmax 0.26.26 → 0.26.28

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

@@ -0,0 +1,665 @@
+"use strict";
+/**
+ * Daemon-side handlers for the `rows.*` read verbs.
+ *
+ * These serve the commands whose store work is a plain row select: `symbols`,
+ * `project`, `extract`, `related`, `log`, `skeleton`. The daemon runs the query
+ * against its already-warm VectorDB and returns the finished answer; the client
+ * renders it and does anything tied to its own cwd, git, or filesystem.
+ *
+ * Every exported `run*` function is the *shared* implementation: the verb
+ * handler calls it with the daemon's VectorDB, and the command's in-process
+ * fallback calls the same function with a VectorDB it opened itself. That is
+ * what makes the two paths byte-identical — there is only one implementation of
+ * each query and each aggregation, and neither path can drift from the other.
+ *
+ * Two things are deliberately *not* raw row proxies:
+ *
+ * - `rows.symbols` returns the aggregated symbol table, not the 2000–10000 rows
+ *   the select produces. The aggregation is pure, so moving it daemon-side
+ *   cannot change the answer, and it turns a multi-megabyte JSON line into a
+ *   list bounded by `--limit`.
+ * - `rows.project` likewise returns the overview, not the rows. `project.ts`
+ *   selects up to 200 000 rows including two symbol-array columns; on the
+ *   platform project (266 753 chunks) proxying those rows would push hundreds
+ *   of megabytes through the daemon's event loop for a summary that fits in a
+ *   few kilobytes. The plan's own reasoning — "verbs at the library-function
+ *   boundary, not a row proxy" — applies here more than anywhere.
+ *
+ * `rows.locate` *is* a row select, because its callers need the rows: extract
+ * reads the file body at the returned line range, log feeds the paths to git,
+ * related counts them. It is batched (an array of matchers, one response) so
+ * `related`'s per-symbol loop costs one round trip instead of hundreds.
+ */
+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.MAX_LOCATE_ROWS = exports.ReadVerbError = void 0;
+exports.withLocalStore = withLocalStore;
+exports.scopeToWire = scopeToWire;
+exports.assertReadableProject = assertReadableProject;
+exports.resolveWireScope = resolveWireScope;
+exports.clampInt = clampInt;
+exports.asReadVerbResponse = asReadVerbResponse;
+exports.runSymbols = runSymbols;
+exports.handleRowsSymbols = handleRowsSymbols;
+exports.runProject = runProject;
+exports.handleRowsProject = handleRowsProject;
+exports.runLocate = runLocate;
+exports.handleRowsLocate = handleRowsLocate;
+exports.runSkeleton = runSkeleton;
+exports.findFileBySymbol = findFileBySymbol;
+exports.readRows = readRows;
+exports.handleRowsSkeleton = handleRowsSkeleton;
+exports.registerRowsVerbs = registerRowsVerbs;
+const callsites_1 = require("../graph/callsites");
+const retriever_1 = require("../skeleton/retriever");
+const arrow_1 = require("../utils/arrow");
+const filter_builder_1 = require("../utils/filter-builder");
+const path_containment_1 = require("../utils/path-containment");
+const project_registry_1 = require("../utils/project-registry");
+const query_timeout_1 = require("../utils/query-timeout");
+const scope_filter_1 = require("../utils/scope-filter");
+const read_verbs_1 = require("./read-verbs");
+/**
+ * Client-side counterpart to `readStoreDeps`: open a private VectorDB, run one
+ * of the shared `run*` functions against it, and close it again.
+ *
+ * This is the *only* place a read command opens the store, and it is reached
+ * only from a `withStoreRead` `inProcess` callback — i.e. only when nothing is
+ * listening on the daemon socket.
+ */
+function withLocalStore(lancedbDir, fn) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { VectorDB } = yield Promise.resolve().then(() => __importStar(require("../store/vector-db")));
+        const db = new VectorDB(lancedbDir);
+        try {
+            return yield fn({ vectorDb: db });
+        }
+        finally {
+            try {
+                yield db.close();
+            }
+            catch (_a) { }
+        }
+    });
+}
+function scopeToWire(scope) {
+    return {
+        pathPrefix: scope.pathPrefix,
+        inPrefixes: scope.inPrefixes,
+        excludePrefixes: scope.excludePrefixes,
+    };
+}
+/** Thrown for a payload the daemon refuses; caught into an error response. */
+class ReadVerbError extends Error {
+    constructor(message, hint) {
+        super(message);
+        this.name = "ReadVerbError";
+        this.hint = hint;
+    }
+}
+exports.ReadVerbError = ReadVerbError;
+/**
+ * Validate `projectRoot` the way the `search` case does: it must name a project
+ * the registry knows and has not marked `error`. An unregistered directory gets
+ * the same "run: gmax add" answer `search` already gives it, rather than a
+ * silently empty result from a scoped scan of the shared table.
+ */
+function assertReadableProject(projectRoot) {
+    if (typeof projectRoot !== "string" || projectRoot === "") {
+        throw new ReadVerbError("missing projectRoot");
+    }
+    const eligible = (0, project_registry_1.listProjects)().filter((p) => p.status !== "error");
+    if (!eligible.some((p) => p.root === projectRoot)) {
+        throw new ReadVerbError("project not registered", `run: gmax add ${projectRoot}`);
+    }
+    return projectRoot;
+}
+/** Resolve one wire prefix against the project root, keeping its trailing slash. */
+function containedPrefix(projectRoot, prefix) {
+    if (typeof prefix !== "string" || prefix === "") {
+        throw new ReadVerbError("invalid path prefix");
+    }
+    const resolved = (0, path_containment_1.resolveContainedPath)(projectRoot, prefix);
+    // resolveContainedPath goes through path.resolve, which drops the trailing
+    // separator that makes a prefix a directory boundary. Put it back only when
+    // the caller had one — `symbols --path src` deliberately matches
+    // `starts_with(path, '<root>/src')` with no trailing slash.
+    return prefix.endsWith("/") ? `${resolved.replace(/\/$/, "")}/` : resolved;
+}
+/** Re-validate a wire scope and rebuild the `ResolvedScope` the queries use. */
+function resolveWireScope(projectRoot, wire) {
+    var _a, _b;
+    const raw = (wire !== null && wire !== void 0 ? wire : {});
+    const projectPrefix = projectRoot.endsWith("/")
+        ? projectRoot
+        : `${projectRoot}/`;
+    return {
+        pathPrefix: raw.pathPrefix === undefined
+            ? projectPrefix
+            : containedPrefix(projectRoot, raw.pathPrefix),
+        inPrefixes: ((_a = raw.inPrefixes) !== null && _a !== void 0 ? _a : []).map((p) => containedPrefix(projectRoot, p)),
+        excludePrefixes: ((_b = raw.excludePrefixes) !== null && _b !== void 0 ? _b : []).map((p) => containedPrefix(projectRoot, p)),
+    };
+}
+/** Clamp an integer payload field into `[min, max]`, falling back on garbage. */
+function clampInt(value, fallback, min, max) {
+    const n = typeof value === "number"
+        ? Math.trunc(value)
+        : Number.parseInt(String(value !== null && value !== void 0 ? value : ""), 10);
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.min(Math.max(n, min), max);
+}
+function tableOf(deps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (!deps.vectorDb)
+            throw new ReadVerbError("daemon not ready");
+        (_a = deps.touchActivity) === null || _a === void 0 ? void 0 : _a.call(deps);
+        return deps.vectorDb.ensureTable();
+    });
+}
+/** Wrap a handler body so a ReadVerbError becomes a clean error response. */
+function asReadVerbResponse(fn) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield fn();
+        }
+        catch (err) {
+            if (err instanceof ReadVerbError) {
+                return err.hint
+                    ? { ok: false, error: err.message, hint: err.hint }
+                    : { ok: false, error: err.message };
+            }
+            throw err;
+        }
+    });
+}
+function toStringArray(val) {
+    if (Array.isArray(val))
+        return val.filter((v) => typeof v === "string");
+    const arr = (0, arrow_1.toArr)(val);
+    return Array.isArray(arr) ? arr.filter((v) => typeof v === "string") : [];
+}
+/**
+ * The `symbols` select plus its aggregation. Same query and same ordering as
+ * before the split; only the process it runs in changed.
+ *
+ * `role` and `is_exported` were added to the select for MCP's `list_symbols`,
+ * which has always tagged each row with them. They cost nothing (the same rows,
+ * two more columns) and `gmax symbols` simply does not render them, so both
+ * callers keep the output they had.
+ */
+function runSymbols(deps, req) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const table = yield tableOf(deps);
+        let query = table
+            .query()
+            .select(["defined_symbols", "path", "start_line", "role", "is_exported"])
+            .where("array_length(defined_symbols) > 0")
+            // Fetch more rows to ensure we have enough after filtering/aggregation
+            .limit(req.pattern ? 10000 : Math.max(req.limit * 50, 2000));
+        if (req.pathPrefix) {
+            query = query.where((0, filter_builder_1.pathStartsWith)((0, filter_builder_1.normalizePath)(req.pathPrefix)));
+        }
+        const rows = yield query.toArray();
+        const map = new Map();
+        for (const row of rows) {
+            const defs = toStringArray(row.defined_symbols);
+            const rowPath = String(row.path || "");
+            const line = Number(row.start_line || 0);
+            const role = String(row.role || "");
+            const exported = Boolean(row.is_exported);
+            for (const sym of defs) {
+                if (req.pattern &&
+                    !sym.toLowerCase().includes(req.pattern.toLowerCase())) {
+                    continue;
+                }
+                const existing = map.get(sym);
+                if (existing) {
+                    existing.count += 1;
+                }
+                else {
+                    map.set(sym, {
+                        symbol: sym,
+                        count: 1,
+                        path: rowPath,
+                        line,
+                        role,
+                        exported,
+                    });
+                }
+            }
+        }
+        return Array.from(map.values())
+            .sort((a, b) => {
+            // Sort by count desc, then symbol asc
+            if (b.count !== a.count)
+                return b.count - a.count;
+            return a.symbol.localeCompare(b.symbol);
+        })
+            .slice(0, req.limit);
+    });
+}
+function handleRowsSymbols(deps, payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return asReadVerbResponse(() => __awaiter(this, void 0, void 0, function* () {
+            const projectRoot = assertReadableProject(payload.projectRoot);
+            const entries = yield runSymbols(deps, {
+                projectRoot,
+                pathPrefix: payload.pathPrefix === undefined
+                    ? undefined
+                    : containedPrefix(projectRoot, payload.pathPrefix),
+                pattern: typeof payload.pattern === "string" && payload.pattern
+                    ? payload.pattern
+                    : undefined,
+                limit: clampInt(payload.limit, 20, 1, 10000),
+            });
+            return { ok: true, entries };
+        }));
+    });
+}
+/**
+ * The `project` scan and its aggregation. Returns the finished overview rather
+ * than the (up to 200 000) rows it was computed from — see the file header.
+ */
+function runProject(deps, projectRoot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const table = yield tableOf(deps);
+        const prefix = projectRoot.endsWith("/") ? projectRoot : `${projectRoot}/`;
+        const rows = yield table
+            .query()
+            .select([
+            "path",
+            "role",
+            "is_exported",
+            "complexity",
+            "defined_symbols",
+            "referenced_symbols",
+        ])
+            .where((0, filter_builder_1.pathStartsWith)(prefix))
+            .limit(200000)
+            .toArray();
+        const nodePath = yield Promise.resolve().then(() => __importStar(require("node:path")));
+        const files = new Set();
+        const extCounts = new Map();
+        const dirCounts = new Map();
+        const roleCounts = new Map();
+        const symbolRefs = new Map();
+        const definedInProject = new Set();
+        const entryPoints = [];
+        const seenEntryPoints = new Set();
+        for (const row of rows) {
+            const r = row;
+            const p = String(r.path || "");
+            const role = String(r.role || "IMPLEMENTATION");
+            const exported = Boolean(r.is_exported);
+            const complexity = Number(r.complexity || 0);
+            const defs = (0, arrow_1.toArr)(r.defined_symbols);
+            const refs = (0, arrow_1.toArr)(r.referenced_symbols);
+            files.add(p);
+            const ext = nodePath.extname(p).toLowerCase() || nodePath.basename(p);
+            extCounts.set(ext, (extCounts.get(ext) || 0) + 1);
+            const rel = p.startsWith(prefix) ? p.slice(prefix.length) : p;
+            const parts = rel.split("/");
+            const dir = parts.length > 2
+                ? `${parts.slice(0, 2).join("/")}/`
+                : parts.length > 1
+                    ? `${parts[0]}/`
+                    : "(root)";
+            if (!dirCounts.has(dir))
+                dirCounts.set(dir, { files: new Set(), chunks: 0 });
+            const dc = dirCounts.get(dir);
+            dc.files.add(p);
+            dc.chunks++;
+            roleCounts.set(role, (roleCounts.get(role) || 0) + 1);
+            for (const d of defs)
+                definedInProject.add(d);
+            for (const ref of refs)
+                symbolRefs.set(ref, (symbolRefs.get(ref) || 0) + 1);
+            if (exported &&
+                role === "ORCHESTRATION" &&
+                complexity >= 5 &&
+                defs.length > 0) {
+                const epKey = `${defs[0]}:${p}`;
+                if (!seenEntryPoints.has(epKey)) {
+                    seenEntryPoints.add(epKey);
+                    entryPoints.push({
+                        symbol: defs[0],
+                        path: p.startsWith(prefix) ? p.slice(prefix.length) : p,
+                    });
+                }
+            }
+        }
+        return {
+            chunks: rows.length,
+            files: files.size,
+            extEntries: Array.from(extCounts.entries())
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 8),
+            // Human output shows 12, agent output shows the first 8 of the same order.
+            dirEntries: Array.from(dirCounts.entries())
+                .sort((a, b) => b[1].chunks - a[1].chunks)
+                .slice(0, 12)
+                .map(([dir, data]) => [dir, { files: data.files.size, chunks: data.chunks }]),
+            roleEntries: Array.from(roleCounts.entries()).sort((a, b) => b[1] - a[1]),
+            // Key symbols must be the project's own: raw referenced_symbols counts
+            // are dominated by JS builtins (push, slice, map, …) which say nothing
+            // about the codebase.
+            topSymbols: Array.from(symbolRefs.entries())
+                .filter(([s]) => definedInProject.has(s) && !(0, callsites_1.isBuiltinCallee)(s))
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 8),
+            entryPoints: entryPoints.slice(0, 10),
+        };
+    });
+}
+function handleRowsProject(deps, payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return asReadVerbResponse(() => __awaiter(this, void 0, void 0, function* () {
+            const projectRoot = assertReadableProject(payload.projectRoot);
+            return { ok: true, overview: yield runProject(deps, projectRoot) };
+        }));
+    });
+}
+// --- rows.locate ------------------------------------------------------------
+/** The column set a row select may ask for. `content` and `vector` are not on it. */
+const LOCATE_COLUMNS = new Set([
+    "path",
+    "start_line",
+    "end_line",
+    "role",
+    "is_exported",
+    "complexity",
+    "defined_symbols",
+    "referenced_symbols",
+    "parent_symbol",
+    "chunk_type",
+    "id",
+]);
+const ARRAY_COLUMNS = new Set(["defined_symbols", "referenced_symbols"]);
+/**
+ * Upper bound on rows one matcher may return when the caller sets no limit.
+ * `related`'s `content LIKE` scan deliberately has no `.limit()` — the limit
+ * pushdown deadlocks on that shape (see query-timeout.ts) — and its JS loop
+ * caps at `--limit` distinct paths, so a wire cap only bites on a query that
+ * would already have been unreasonable to render.
+ */
+exports.MAX_LOCATE_ROWS = 5000;
+function matchCondition(match) {
+    switch (match.kind) {
+        case "definedSymbol":
+            return {
+                where: `array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(match.symbol)}')`,
+                label: `defined_symbols ∋ ${match.symbol}`,
+            };
+        case "referencedSymbol":
+            return {
+                where: `array_contains(referenced_symbols, '${(0, filter_builder_1.escapeSqlString)(match.symbol)}')`,
+                label: `referenced_symbols ∋ ${match.symbol}`,
+            };
+        case "path":
+            return {
+                where: `path = '${(0, filter_builder_1.escapeSqlString)(match.path)}'`,
+                label: `path = ${match.path}`,
+            };
+        case "contentLike":
+            return {
+                where: `content LIKE '%${(0, filter_builder_1.escapeSqlString)(match.value)}%'`,
+                label: `content LIKE %${match.value}% (related mentions)`,
+            };
+    }
+}
+/**
+ * Normalize one Lance row to plain JSON. Arrow list columns do not survive
+ * JSON.stringify as arrays, so they are converted here — in the *shared*
+ * function, which means the in-process path sees exactly the same shape the
+ * socket delivers.
+ */
+function normalizeRow(row, select) {
+    const src = row;
+    const out = {};
+    for (const col of select) {
+        const value = src[col];
+        if (ARRAY_COLUMNS.has(col))
+            out[col] = (0, arrow_1.toArr)(value);
+        else if (col === "is_exported")
+            out[col] = Boolean(value);
+        else if (col === "start_line" || col === "end_line" || col === "complexity")
+            out[col] = Number(value !== null && value !== void 0 ? value : 0);
+        else
+            out[col] = value === undefined || value === null ? "" : String(value);
+    }
+    return out;
+}
+/** Run a batch of row selects, one result array per matcher, order preserved. */
+function runLocate(deps, req) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const table = yield tableOf(deps);
+        const scoped = req.scoped !== false;
+        const pathScope = (0, scope_filter_1.buildScopeWhere)(req.scope);
+        const results = [];
+        for (const match of req.matches) {
+            const { where, label } = matchCondition(match);
+            let query = table
+                .query()
+                .select(req.select)
+                .where(scoped ? `${where} AND ${pathScope}` : where);
+            if (req.limit !== undefined)
+                query = query.limit(req.limit);
+            const rows = yield (0, query_timeout_1.withQueryTimeout)(query.toArray(), label);
+            results.push(rows
+                .slice(0, (_a = req.limit) !== null && _a !== void 0 ? _a : exports.MAX_LOCATE_ROWS)
+                .map((row) => normalizeRow(row, req.select)));
+        }
+        return results;
+    });
+}
+function handleRowsLocate(deps, payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return asReadVerbResponse(() => __awaiter(this, void 0, void 0, function* () {
+            const projectRoot = assertReadableProject(payload.projectRoot);
+            const scope = resolveWireScope(projectRoot, payload.scope);
+            const select = Array.isArray(payload.select)
+                ? payload.select.filter((c) => typeof c === "string" && LOCATE_COLUMNS.has(c))
+                : [];
+            if (select.length === 0)
+                throw new ReadVerbError("invalid select");
+            const rawMatches = Array.isArray(payload.matches) ? payload.matches : [];
+            if (rawMatches.length === 0)
+                throw new ReadVerbError("missing matches");
+            if (rawMatches.length > 2000)
+                throw new ReadVerbError("too many matches");
+            const matches = rawMatches.map((m) => {
+                const match = m;
+                if ((match.kind === "definedSymbol" || match.kind === "referencedSymbol") &&
+                    typeof match.symbol === "string") {
+                    return match;
+                }
+                if (match.kind === "path" &&
+                    typeof match.path === "string") {
+                    // A path matcher is an exact equality on an indexed absolute path;
+                    // containment keeps it inside the project the caller named.
+                    return {
+                        kind: "path",
+                        path: (0, path_containment_1.resolveContainedPath)(projectRoot, match.path),
+                    };
+                }
+                if (match.kind === "contentLike" &&
+                    typeof match.value === "string") {
+                    return match;
+                }
+                throw new ReadVerbError("invalid match");
+            });
+            const rows = yield runLocate(deps, {
+                projectRoot,
+                scope,
+                select,
+                matches,
+                limit: payload.limit === undefined
+                    ? undefined
+                    : clampInt(payload.limit, 10, 1, exports.MAX_LOCATE_ROWS),
+                scoped: payload.scoped !== false,
+            });
+            return { ok: true, rows };
+        }));
+    });
+}
+/**
+ * `skeleton`'s two store reads: the FTS symbol → file lookup and the stored
+ * per-file skeleton. Both are best-effort and return null rather than throwing,
+ * exactly as `findFileBySymbol` and `getStoredSkeleton` always have.
+ */
+function runSkeleton(deps, req) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        if (!deps.vectorDb)
+            throw new ReadVerbError("daemon not ready");
+        (_a = deps.touchActivity) === null || _a === void 0 ? void 0 : _a.call(deps);
+        const db = deps.vectorDb;
+        let filePath = (_b = req.path) !== null && _b !== void 0 ? _b : null;
+        if (!filePath && req.symbol) {
+            filePath = yield findFileBySymbol(db, req.symbol, req.projectRoot);
+        }
+        if (!filePath)
+            return { path: null, skeleton: null };
+        return { path: filePath, skeleton: yield (0, retriever_1.getStoredSkeleton)(db, filePath) };
+    });
+}
+/** FTS lookup for the file that defines `symbol`; null when nothing matches. */
+function findFileBySymbol(db, symbol, projectRoot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const table = yield db.ensureTable();
+            const results = yield table
+                .search(symbol)
+                .where((0, filter_builder_1.pathStartsWith)(`${projectRoot}/`))
+                .limit(10)
+                .toArray();
+            for (const result of results) {
+                const defined = result.defined_symbols;
+                if ((0, arrow_1.toArr)(defined).includes(symbol)) {
+                    return String(result.path);
+                }
+            }
+            if (results.length > 0) {
+                return String(results[0].path);
+            }
+            return null;
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
+/**
+ * Client side of `rows.locate`: one round trip for a whole batch of matchers,
+ * falling back to the same `runLocate` in-process when no daemon is listening.
+ * Shared by extract, related, log, and context so the wire shape has exactly
+ * one producer and one consumer.
+ */
+function readRows(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (opts.matches.length === 0)
+            return [];
+        const { sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../utils/daemon-client")));
+        const { withStoreRead } = yield Promise.resolve().then(() => __importStar(require("../utils/store-access")));
+        return withStoreRead(opts.name, Object.assign({ daemon: () => {
+                var _a;
+                return sendDaemonCommand({
+                    cmd: "rows.locate",
+                    projectRoot: opts.projectRoot,
+                    scope: scopeToWire(opts.scope),
+                    select: opts.select,
+                    matches: opts.matches,
+                    limit: opts.limit,
+                    scoped: opts.scoped,
+                }, { timeoutMs: (_a = opts.timeoutMs) !== null && _a !== void 0 ? _a : 60000 });
+            }, render: (resp) => { var _a; return ((_a = resp.rows) !== null && _a !== void 0 ? _a : []); }, inProcess: () => withLocalStore(opts.lancedbDir, (deps) => runLocate(deps, {
+                projectRoot: opts.projectRoot,
+                scope: opts.scope,
+                select: opts.select,
+                matches: opts.matches,
+                limit: opts.limit,
+                scoped: opts.scoped,
+            })), fallbackOnUnknownVerb: true }, opts.fallback));
+    });
+}
+function handleRowsSkeleton(deps, payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return asReadVerbResponse(() => __awaiter(this, void 0, void 0, function* () {
+            const projectRoot = assertReadableProject(payload.projectRoot);
+            const target = typeof payload.path === "string" && payload.path
+                ? (0, path_containment_1.resolveContainedPath)(projectRoot, payload.path)
+                : undefined;
+            const symbol = typeof payload.symbol === "string" && payload.symbol
+                ? payload.symbol
+                : undefined;
+            if (!target && !symbol)
+                throw new ReadVerbError("missing path or symbol");
+            const result = yield runSkeleton(deps, {
+                projectRoot,
+                path: target,
+                symbol,
+            });
+            return Object.assign({ ok: true }, result);
+        }));
+    });
+}
+// --- Registration -----------------------------------------------------------
+/**
+ * Called from `Daemon.start()`, not at module scope: the registry's exact
+ * contents are asserted on in tests/ipc-read-verbs.test.ts, and registering on
+ * import would make it non-empty the moment ipc-handler is loaded.
+ */
+function registerRowsVerbs() {
+    (0, read_verbs_1.registerReadVerbs)({
+        "rows.symbols": (payload, ctx) => handleRowsSymbols(ctx.daemon.storeReadDeps(), payload),
+        "rows.project": (payload, ctx) => handleRowsProject(ctx.daemon.storeReadDeps(), payload),
+        "rows.locate": (payload, ctx) => handleRowsLocate(ctx.daemon.storeReadDeps(), payload),
+        "rows.skeleton": (payload, ctx) => handleRowsSkeleton(ctx.daemon.storeReadDeps(), payload),
+    });
+}