@esneiderbravo/speclaw 2.0.12 → 2.0.13

package/dist/modules/compass/extract.js

@@ -36,6 +36,176 @@ function calleeName(node, lang) {
 }
 /** Python receivers that mean "this class/instance". */
 const PY_SELF = new Set(["self", "cls"]);
+/**
+ * Type names that never become a `ref` edge: TypeScript lib and utility types
+ * and JS built-in constructors (predefined types like `string` are separate
+ * tree-sitter nodes and never reach here; they are listed for safety).
+ */
+const BUILTIN_TYPES = new Set([
+    "string",
+    "number",
+    "boolean",
+    "bigint",
+    "symbol",
+    "object",
+    "any",
+    "unknown",
+    "never",
+    "void",
+    "undefined",
+    "null",
+    "Array",
+    "ReadonlyArray",
+    "ArrayLike",
+    "Promise",
+    "PromiseLike",
+    "Awaited",
+    "Record",
+    "Partial",
+    "Required",
+    "Readonly",
+    "Pick",
+    "Omit",
+    "Exclude",
+    "Extract",
+    "NonNullable",
+    "ReturnType",
+    "Parameters",
+    "ConstructorParameters",
+    "InstanceType",
+    "ThisType",
+    "ThisParameterType",
+    "OmitThisParameter",
+    "Uppercase",
+    "Lowercase",
+    "Capitalize",
+    "Uncapitalize",
+    "Map",
+    "Set",
+    "WeakMap",
+    "WeakSet",
+    "WeakRef",
+    "ReadonlyMap",
+    "ReadonlySet",
+    "Date",
+    "RegExp",
+    "Error",
+    "TypeError",
+    "RangeError",
+    "Function",
+    "Object",
+    "String",
+    "Number",
+    "Boolean",
+    "Symbol",
+    "BigInt",
+    "Iterable",
+    "Iterator",
+    "IterableIterator",
+    "AsyncIterable",
+    "AsyncIterator",
+    "AsyncIterableIterator",
+    "Generator",
+    "AsyncGenerator",
+    "PropertyKey",
+    "JSON",
+    "Math",
+    "ArrayBuffer",
+    "SharedArrayBuffer",
+    "DataView",
+    "Int8Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Int16Array",
+    "Uint16Array",
+    "Int32Array",
+    "Uint32Array",
+    "Float32Array",
+    "Float64Array",
+    "BigInt64Array",
+    "BigUint64Array",
+    "TemplateStringsArray",
+]);
+/** AST nodes whose subtree names types: annotations and heritage clauses. */
+const TYPE_REF_NODES = new Set([
+    "type_annotation",
+    "extends_type_clause",
+    "implements_clause",
+    "extends_clause",
+]);
+/** `Type` of a qualified `ns.Type` / `a.b.Type` node, with its qualifier. */
+function qualifiedTypeName(node, nameType) {
+    let name = null;
+    let module = null;
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (!c)
+            continue;
+        if (c.type === nameType)
+            name = c;
+        else if (module === null && c.type !== ".")
+            module = c;
+    }
+    if (!name)
+        return null;
+    return {
+        name: name.text,
+        line: name.startPosition.row + 1,
+        pos: name.startIndex,
+        qualifier: module?.type === "identifier" ? module.text : "",
+    };
+}
+/** Collect every type named inside a type subtree (generic arguments included). */
+function typeNamesIn(node, out) {
+    if (node.type === "type_identifier") {
+        out.push({
+            name: node.text,
+            line: node.startPosition.row + 1,
+            pos: node.startIndex,
+            qualifier: null,
+        });
+        return;
+    }
+    if (node.type === "nested_type_identifier") {
+        const q = qualifiedTypeName(node, "type_identifier");
+        if (q)
+            out.push(q);
+        return;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c)
+            typeNamesIn(c, out);
+    }
+}
+/**
+ * Types a heritage or annotation node names. A class `extends` value is an
+ * expression (`Base`, `ns.Base`), not a type node, so it is read directly.
+ */
+function typeRefsOf(node) {
+    const out = [];
+    if (node.type !== "extends_clause" && node.type !== "class_heritage") {
+        typeNamesIn(node, out);
+        return out;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (!c)
+            continue;
+        if (c.type === "identifier") {
+            out.push({ name: c.text, line: c.startPosition.row + 1, pos: c.startIndex, qualifier: null });
+        }
+        else if (c.type === "member_expression") {
+            const q = qualifiedTypeName(c, "property_identifier");
+            if (q)
+                out.push(q);
+        }
+        else if (c.type === "type_arguments") {
+            typeNamesIn(c, out);
+        }
+    }
+    return out;
+}
 /**
  * The receiver of a member call (`recv.f()`), or null for a plain call.
  * `kind` is `self` for `this`/`super`/`self`/`cls`, `ident` for a bare
@@ -339,6 +509,12 @@ export async function extract(source, lang) {
     // binding's import (matched by `spec`) resolved to a project file.
     const identReceivers = [];
     const bareCalls = [];
+    // Type references: one per (owner, name); qualified ones are classified like
+    // member calls once the import bindings are known. A bare name inside the
+    // declaration that introduces a same-named type parameter (`<Props>`) is that
+    // parameter and is dropped; the same name elsewhere in the file is kept.
+    const typeNames = [];
+    const typeParamScopes = [];
     const bindings = new Set();
     // JS/TS import binding → its import's module specifier.
     const bindingSpecs = new Map();
@@ -410,6 +586,25 @@ export async function extract(source, lang) {
                 spec,
             });
         }
+        else if (lang.id !== "python" &&
+            (TYPE_REF_NODES.has(node.type) ||
+                (lang.id === "javascript" && node.type === "class_heritage"))) {
+            // Covers: req~type-ref-edges~1
+            for (const t of typeRefsOf(node)) {
+                if (t.qualifier === null && BUILTIN_TYPES.has(t.name))
+                    continue;
+                typeNames.push({ t, ownerIndex });
+            }
+        }
+        else if (node.type === "type_parameter") {
+            // Scope: the declaration owning the `<…>` list (function, method, arrow,
+            // class, interface, type alias, function type), never the whole file.
+            const name = node.child(0);
+            const scope = node.parent?.parent ?? node.parent;
+            if (name?.type === "type_identifier" && scope) {
+                typeParamScopes.push({ name: name.text, start: scope.startIndex, end: scope.endIndex });
+            }
+        }
         else if (COMMENT_TYPES.has(node.type)) {
             rawCoverage.push(...parseCoverageComment(node, ownerIndex));
         }
@@ -433,5 +628,30 @@ export async function extract(source, lang) {
     }
     for (const ref of bareCalls)
         ref.spec = bindingSpecs.get(ref.name) ?? null;
+    // A bare type name carries its import binding's spec (resolved like a bare
+    // call); `ns.Type` on an import binding is a member ref (2), else foreign (1).
+    // Scoped type parameters are filtered before de-duplication, so a dropped
+    // parameter never hides a real reference of the same owner.
+    const typeRefKeys = new Set();
+    for (const { t, ownerIndex } of typeNames) {
+        if (t.qualifier === null &&
+            typeParamScopes.some((p) => p.name === t.name && p.start <= t.pos && t.pos < p.end)) {
+            continue;
+        }
+        const key = `${ownerIndex ?? "file"}:${t.name}`;
+        if (typeRefKeys.has(key))
+            continue;
+        typeRefKeys.add(key);
+        let member = 0;
+        let spec;
+        if (t.qualifier === null) {
+            spec = bindingSpecs.get(t.name) ?? null;
+        }
+        else {
+            spec = t.qualifier ? (bindingSpecs.get(t.qualifier) ?? null) : null;
+            member = spec !== null ? 2 : 1;
+        }
+        refs.push({ name: t.name, kind: "ref", line: t.line, ownerIndex, member, spec });
+    }
     return { symbols, refs, coverage: attachCoverage(rawCoverage, symbols), reexports };
 }

package/dist/modules/compass/find-output.js

@@ -0,0 +1,172 @@
+/**
+ * MCP response of `compass_find` (and its `compass_search` / `compass_recall`
+ * aliases): compact hits and one JSON document capped as a whole at the
+ * caller's token budget. The CLI keeps printing `HybridSearchResult` as is.
+ */
+import { renderTreeContext } from "./budget.js";
+import { estimateTokens } from "../../shared/output-budget.js";
+function compact(h) {
+    return { name: h.name, kind: h.kind, file: h.file, line: h.line };
+}
+/** Rendered blocks for the first `count` hits, the same TreeContext the search produced. */
+function renderHits(hits, count) {
+    return renderTreeContext(hits.slice(0, count));
+}
+/**
+ * Serialise `response` behind `prefix`, writing `tokens` last so it equals the
+ * estimate of the whole emitted text (at most a few passes until the digit
+ * count is stable).
+ */
+function emit(prefix, response) {
+    response.tokens = 0;
+    let out = prefix + JSON.stringify(response);
+    for (let i = 0; i < 4; i++) {
+        const t = estimateTokens(out);
+        if (t === response.tokens)
+            break;
+        response.tokens = t;
+        out = prefix + JSON.stringify(response);
+    }
+    return out;
+}
+/** Cut `rendered` to about `chars` characters at a line break, marking the elision. */
+function shortenRendered(rendered, chars) {
+    if (chars <= 0)
+        return "";
+    if (rendered.length <= chars)
+        return rendered;
+    const head = rendered.slice(0, chars);
+    const cut = head.lastIndexOf("\n");
+    return `${cut > 0 ? head.slice(0, cut) : head}\n⋮`;
+}
+/**
+ * Largest `k` in `[0, len]` for which `fitsAt(k)` holds, assuming fitting is
+ * monotone in `k` (a shorter list never makes the text longer); `-1` when even
+ * an empty list does not fit.
+ */
+function largestFitting(len, fitsAt) {
+    if (!fitsAt(0))
+        return -1;
+    let lo = 0;
+    let hi = len;
+    while (lo < hi) {
+        const mid = Math.ceil((lo + hi) / 2);
+        if (fitsAt(mid))
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return lo;
+}
+/**
+ * Format a find result as the exact text `compass_find` emits: one JSON
+ * document (no indentation) whose estimated tokens never exceed the cap.
+ * Over the cap it first trims `focusIgnored`, `focus`, and `terms` from the
+ * end (each trimmed list reports its original length in a `…Total` field),
+ * then drops the lowest-ranked hits together with their rendered blocks, then
+ * shortens `rendered` of the last hit, then drops `nearest` entries from the
+ * end. `truncated` is set when the search or the formatter removed
+ * anything, so the cap holds and the text parses as JSON for any input.
+ *
+ * @param result - Output of {@link findSymbols}.
+ * @param opts - `prefix` is emitted before the JSON (alias deprecation notice)
+ *   and counts toward the cap and `tokens`.
+ * @returns The text to pass to `text(str, { maxTokens: result.cap })`.
+ */
+// Covers: req~find-response-budget~1
+export function formatFindResponse(result, opts = {}) {
+    const prefix = opts.prefix ?? "";
+    const cap = result.cap;
+    let count = result.hits.length;
+    let rendered = result.rendered;
+    let nearest = result.nearest ? result.nearest.map(compact) : undefined;
+    let truncated = result.capped;
+    const terms = result.terms ?? [];
+    // Kept lengths of the context lists; trimmed before any hit.
+    let termsKept = terms.length;
+    let focusKept = result.focus.length;
+    let ignoredKept = result.focusIgnored.length;
+    const build = () => ({
+        mode: result.mode,
+        ...(result.mode === "exact"
+            ? {
+                found: result.found ?? false,
+                terms: terms.slice(0, termsKept),
+                ...(termsKept < terms.length ? { termsTotal: terms.length } : {}),
+            }
+            : {}),
+        rendered,
+        hits: result.hits.slice(0, count).map(compact),
+        ...(nearest ? { nearest } : {}),
+        focus: result.focus.slice(0, focusKept),
+        ...(focusKept < result.focus.length ? { focusTotal: result.focus.length } : {}),
+        ...(result.focusIgnored.length > 0
+            ? { focusIgnored: result.focusIgnored.slice(0, ignoredKept) }
+            : {}),
+        ...(ignoredKept < result.focusIgnored.length
+            ? { focusIgnoredTotal: result.focusIgnored.length }
+            : {}),
+        ...(result.degraded.length > 0 ? { degraded: result.degraded } : {}),
+        tokens: 0,
+        budget: cap,
+        ...(truncated ? { truncated: true } : {}),
+    });
+    const fits = () => {
+        const out = emit(prefix, build());
+        return estimateTokens(out) <= cap ? out : null;
+    };
+    let out = fits();
+    // 1. Trim the context lists from the end: focusIgnored, focus, then terms.
+    // They matter less than the payload, so they go before any hit. Each list is
+    // cut to the longest prefix that fits (binary search, so a worktree with
+    // thousands of changes costs O(log n) serialisations), or emptied.
+    const lists = [
+        { len: result.focusIgnored.length, set: (k) => (ignoredKept = k) },
+        { len: result.focus.length, set: (k) => (focusKept = k) },
+        { len: terms.length, set: (k) => (termsKept = k) },
+    ];
+    for (const list of lists) {
+        if (out || list.len === 0)
+            continue;
+        truncated = true;
+        const k = largestFitting(list.len, (n) => {
+            list.set(n);
+            return fits() !== null;
+        });
+        list.set(Math.max(k, 0));
+        out = fits();
+    }
+    // 2. Drop the lowest-ranked hits with their rendered blocks.
+    while (!out && count > 1) {
+        count--;
+        rendered = renderHits(result.hits, count);
+        truncated = true;
+        out = fits();
+    }
+    // 3. One hit left: shorten its rendered block.
+    if (!out && rendered) {
+        truncated = true;
+        rendered = "";
+        const room = (cap - estimateTokens(emit(prefix, build()))) * 4 - 8;
+        rendered = shortenRendered(renderHits(result.hits, count), room);
+        out = fits();
+        if (!out) {
+            rendered = "";
+            out = fits();
+        }
+    }
+    // 4. Drop nearest entries from the end.
+    while (!out && nearest && nearest.length > 0) {
+        nearest = nearest.slice(0, -1);
+        truncated = true;
+        out = fits();
+    }
+    // 5. Last resort (a prefix or single hit larger than the cap): drop the hit.
+    if (!out && count > 0) {
+        count = 0;
+        rendered = "";
+        truncated = true;
+        out = fits();
+    }
+    return out ?? emit(prefix, build());
+}

package/dist/modules/compass/hybrid.js

@@ -2,8 +2,9 @@
  * Hybrid retrieval pipeline: BM25 + KNN + name → RRF → ego expand →
  * personalized PageRank → structural rerank → token budget.
  */
+import path from "node:path";
 import { openDb, indexExists, ftsAvailable, FILE_NODE_KIND } from "./db.js";
-import { getEmbedder, fromBlob, cosine } from "./embedder.js";
+import { getEmbedder, fromBlob, cosine, tokenize } from "./embedder.js";
 import { isGitRepo, worktreeChangedFiles } from "../../shared/git.js";
 import { escapeFtsQuery, nameBoost, routeWeights, rrfFuse, structuralScore, MAX_DEGREE, isSymbolQuery, } from "./rank.js";
 import { personalizedPageRank, edgeWeightMul } from "./pagerank.js";
@@ -13,18 +14,48 @@ function requireIndex(projectPath) {
         throw new Error("No index found. Build it first with the index_build tool (creates .speclaw/index.db).");
     }
 }
+/** Repo-relative, slash-separated form of a focus path (absolute paths under the root too). */
+function normaliseFocusPath(projectPath, raw) {
+    let p = raw.trim().split("\\").join("/");
+    if (path.isAbsolute(p)) {
+        const rel = path.relative(projectPath, p).split(path.sep).join("/");
+        if (!rel.startsWith("..") && !path.isAbsolute(rel))
+            p = rel;
+    }
+    while (p.startsWith("./"))
+        p = p.slice(2);
+    return p;
+}
 /**
- * Resolve focus paths: explicit list, else worktree changes, else empty.
+ * Resolve the focus set against the index: the explicit list, else the git
+ * working-tree changes, normalised and kept only when present in `files`.
+ * Dropped inputs are reported as given. Non-git with no explicit focus → empty.
  *
+ * @param db - Open index database.
  * @param projectPath - Project root.
  * @param focus - Optional explicit paths.
  */
-export function resolveFocus(projectPath, focus) {
-    if (focus && focus.length > 0)
-        return [...new Set(focus)];
-    if (!isGitRepo(projectPath))
-        return [];
-    return worktreeChangedFiles(projectPath);
+// Covers: req~task-relative-ranking~1
+export function resolveSearchFocus(db, projectPath, focus) {
+    const inputs = focus && focus.length > 0
+        ? focus
+        : isGitRepo(projectPath)
+            ? worktreeChangedFiles(projectPath)
+            : [];
+    const has = db.prepare("SELECT 1 AS ok FROM files WHERE path = ?");
+    const kept = [];
+    const ignored = [];
+    for (const raw of inputs) {
+        const p = normaliseFocusPath(projectPath, raw);
+        if (p && has.get(p)) {
+            if (!kept.includes(p))
+                kept.push(p);
+        }
+        else if (!ignored.includes(raw)) {
+            ignored.push(raw);
+        }
+    }
+    return { focus: kept, ignored };
 }
 /**
  * Hybrid code search over the local Compass index.
@@ -37,8 +68,6 @@ export async function hybridSearch(projectPath, query, opts = {}) {
     requireIndex(projectPath);
     const degraded = [];
     const q = query.trim();
-    const focus = resolveFocus(projectPath, opts.focus);
-    const focusSet = new Set(focus);
     const mode = opts.mode;
     const route = mode === "exact"
         ? "symbol"
@@ -53,10 +82,14 @@ export async function hybridSearch(projectPath, query, opts = {}) {
         weights.knn = 1.0;
         weights.name = 0.5;
     }
-    const budget = opts.maxTokens ?? defaultBudget(focus.length > 0);
     const seedLimit = opts.seedLimit ?? 50;
+    const exactNames = opts.exactNames ? [...new Set(opts.exactNames)] : null;
     const db = openDb(projectPath);
     try {
+        const resolved = opts.resolvedFocus ?? resolveSearchFocus(db, projectPath, opts.focus);
+        const focus = resolved.focus;
+        const focusSet = new Set(focus);
+        const budget = opts.maxTokens ?? defaultBudget(focus.length > 0);
         const hasFts = ftsAvailable(db);
         if (!hasFts)
             degraded.push("fts5-unavailable");
@@ -109,6 +142,23 @@ export async function hybridSearch(projectPath, query, opts = {}) {
         }
         const nameIds = [];
         const nameRank = new Map();
+        // Covers: req~find-exact-not-found~1
+        // Exact mode: every symbol named exactly a term joins the name list first,
+        // so the full-text AND of a multi-term query cannot drop one of them.
+        const exactIds = new Set();
+        if (exactNames && exactNames.length > 0) {
+            const rows = db
+                .prepare(`SELECT n.id FROM nodes n
+           WHERE n.name IN (${exactNames.map(() => "?").join(",")})
+             AND n.kind <> '${FILE_NODE_KIND}'
+           ORDER BY n.id`)
+                .all(...exactNames);
+            for (const r of rows) {
+                exactIds.add(r.id);
+                nameIds.push(r.id);
+                nameRank.set(r.id, nameIds.length);
+            }
+        }
         if (q) {
             const likeRows = db
                 .prepare(`SELECT n.id
@@ -117,10 +167,12 @@ export async function hybridSearch(projectPath, query, opts = {}) {
            ORDER BY (n.name = ?) DESC, length(n.name) ASC
            LIMIT 20`)
                 .all(`%${q}%`, q);
-            likeRows.forEach((r, i) => {
+            for (const r of likeRows) {
+                if (nameRank.has(r.id))
+                    continue;
                 nameIds.push(r.id);
-                nameRank.set(r.id, i + 1);
-            });
+                nameRank.set(r.id, nameIds.length);
+            }
         }
         const fused = rrfFuse({ bm25: bm25Ids, knn: knnIds, name: nameIds }, { bm25: weights.bm25, knn: weights.knn, name: weights.name });
         // Apply name boost using node names.
@@ -145,6 +197,11 @@ export async function hybridSearch(projectPath, query, opts = {}) {
             }
         }
         let seeds = [...fused.entries()].sort((a, b) => b[1] - a[1]).slice(0, seedLimit);
+        // An exact-named symbol is always seeded, however crowded the fused list.
+        for (const id of exactIds) {
+            if (!seeds.some(([s]) => s === id))
+                seeds.push([id, fused.get(id) ?? 0]);
+        }
         // Empty / stopword query: top by global pagerank in focus (or global).
         if (!q || seeds.length === 0) {
             const rows = focus.length > 0
@@ -292,13 +349,14 @@ export async function hybridSearch(projectPath, query, opts = {}) {
             };
         })
             .sort((a, b) => b.signals.score - a.signals.score);
-        if (focus.length > 0) {
-            const known = new Set(files.map((f) => f.path));
-            if (focus.every((p) => !known.has(p))) {
-                degraded.push("focus-unindexed");
-            }
+        if (focus.length === 0 && resolved.ignored.length > 0)
+            degraded.push("focus-unindexed");
+        const kept = exactNames ? ranked.filter((h) => exactNames.includes(h.name)) : ranked;
+        if (opts.report) {
+            opts.report.ranked = kept.length;
+            opts.report.knnIds = [...knnIds];
         }
-        const budgetHits = ranked.map((h) => ({
+        const budgetHits = kept.map((h) => ({
             name: h.name,
             kind: h.kind,
             file: h.file,
@@ -306,7 +364,7 @@ export async function hybridSearch(projectPath, query, opts = {}) {
             signature: h.signature,
         }));
         const fitted = fitToBudget(budgetHits, budget);
-        const finalHits = ranked.slice(0, fitted.hitCount);
+        const finalHits = kept.slice(0, fitted.hitCount);
         return {
             rendered: fitted.rendered,
             tokens: fitted.tokens,
@@ -321,3 +379,73 @@ export async function hybridSearch(projectPath, query, opts = {}) {
         db.close();
     }
 }
+/**
+ * Identifier terms of an exact-mode query: split on whitespace, commas, `|`,
+ * and `;`, keep identifier-shaped tokens (dotted names allowed), de-duplicate
+ * in order.
+ *
+ * @param query - Raw query text.
+ */
+// Covers: req~find-exact-not-found~1
+export function exactTerms(query) {
+    const out = [];
+    for (const tok of query.split(/[\s,|;]+/)) {
+        if (/^[A-Za-z_$][\w$.]*$/.test(tok) && !out.includes(tok))
+            out.push(tok);
+    }
+    return out;
+}
+const NEAREST_LIMIT = 5;
+/**
+ * Up to five symbols near names that do not exist, de-duplicated by node and
+ * never file-owner nodes: indexed names (≥ 3 chars) contained in a term,
+ * longest first; then case-insensitive equality, then the most shared
+ * camelCase/snake subtokens; vector neighbours last.
+ *
+ * @param projectPath - Indexed project root.
+ * @param terms - The exact-mode terms that matched no symbol.
+ * @param knnIds - Vector-list node ids from the search, best first.
+ */
+// Covers: req~find-exact-not-found~1
+export function nearestSymbols(projectPath, terms, knnIds) {
+    const db = openDb(projectPath);
+    try {
+        const rows = db
+            .prepare(`SELECT n.id, n.name, n.kind, f.path AS file, n.start_line AS line
+         FROM nodes n JOIN files f ON f.id = n.file_id
+         WHERE n.kind <> '${FILE_NODE_KIND}'
+         ORDER BY n.id`)
+            .all();
+        const out = [];
+        const seen = new Set();
+        const take = (list) => {
+            for (const r of list) {
+                if (out.length >= NEAREST_LIMIT)
+                    return;
+                if (seen.has(r.id))
+                    continue;
+                seen.add(r.id);
+                out.push(r);
+            }
+        };
+        take(rows
+            .filter((r) => r.name.length >= 3 && terms.some((t) => t !== r.name && t.includes(r.name)))
+            .sort((a, b) => b.name.length - a.name.length || a.id - b.id));
+        const lowered = terms.map((t) => t.toLowerCase());
+        take(rows.filter((r) => lowered.includes(r.name.toLowerCase())));
+        const termTokens = new Set(terms.flatMap((t) => tokenize(t)));
+        if (termTokens.size > 0) {
+            take(rows
+                .map((r) => ({ r, shared: tokenize(r.name).filter((t) => termTokens.has(t)).length }))
+                .filter((x) => x.shared > 0)
+                .sort((a, b) => b.shared - a.shared || a.r.id - b.r.id)
+                .map((x) => x.r));
+        }
+        const byId = new Map(rows.map((r) => [r.id, r]));
+        take(knnIds.map((id) => byId.get(id)).filter((r) => !!r));
+        return out.map(({ name, kind, file, line }) => ({ name, kind, file, line }));
+    }
+    finally {
+        db.close();
+    }
+}