brainbank 0.1.0-beta.1

package/src/providers/pruners/haiku-expander.ts

@@ -0,0 +1,166 @@
+/**
+ * BrainBank — Haiku Expander
+ *
+ * LLM-powered context expansion using Anthropic's Haiku 4.5 model.
+ * After search + pruning, reviews a manifest of available chunks
+ * and requests additional IDs to include.
+ *
+ * Flow:
+ *   1. Receives lightweight manifest (~20 chars per chunk)
+ *   2. Haiku selects additional chunk IDs (just numbers, fast)
+ *   3. Caller fetches those chunks from DB and splices into results
+ *
+ * Designed for minimal token usage:
+ *   - Input: ~2,000-3,000 tokens (manifest)
+ *   - Output: ~50-100 tokens (ID array)
+ *   - Cost: ~$0.001 per call
+ *   - Latency: ~300-600ms
+ *
+ * Fail-open: any error returns empty array (no expansion).
+ */
+
+import type { Expander, ExpanderManifestItem, ExpanderResult } from '@/types.ts';
+
+const DEFAULT_MODEL = 'claude-haiku-4-5-20251001';
+
+export interface HaikuExpanderOptions {
+    /** Anthropic API key. Falls back to ANTHROPIC_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: claude-haiku-4-5-20251001 */
+    model?: string;
+}
+
+export class HaikuExpander implements Expander {
+    private readonly _apiKey: string;
+    private readonly _model: string;
+
+    constructor(options: HaikuExpanderOptions = {}) {
+        this._apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY ?? '';
+        this._model = options.model ?? DEFAULT_MODEL;
+
+        if (!this._apiKey) {
+            throw new Error(
+                'HaikuExpander: No API key provided. Set ANTHROPIC_API_KEY env var or pass apiKey option.',
+            );
+        }
+    }
+
+    async expand(
+        query: string,
+        currentIds: number[],
+        manifest: ExpanderManifestItem[],
+    ): Promise<ExpanderResult> {
+        if (manifest.length === 0) return { ids: [] };
+
+        // Filter out chunks already in results
+        const currentSet = new Set(currentIds);
+        const available = manifest.filter(m => !currentSet.has(m.id));
+        if (available.length === 0) return { ids: [] };
+
+        // Split manifest into priority (import-graph neighbors) and general
+        const priorityChunks = available.filter(m => m.priority);
+        const otherChunks = available.filter(m => !m.priority);
+
+        const currentSummary = manifest
+            .filter(m => currentSet.has(m.id))
+            .map(m => `#${m.id} ${m.filePath} | ${m.chunkType} ${m.name}`)
+            .join('\n');
+
+        // Build manifest sections
+        let manifestSection = '';
+        if (priorityChunks.length > 0) {
+            const prioLines = priorityChunks.map(m =>
+                `#${m.id} ${m.filePath} | ${m.chunkType} ${m.name} ${m.lines}`
+            ).join('\n');
+            manifestSection += `DEPENDENCY chunks (imported by or importing the search result files):\n${prioLines}\n\n`;
+        }
+        if (otherChunks.length > 0) {
+            const otherLines = otherChunks.map(m =>
+                `#${m.id} ${m.filePath} | ${m.chunkType} ${m.name} ${m.lines}`
+            ).join('\n');
+            manifestSection += `Other available chunks:\n${otherLines}`;
+        }
+
+        const prompt =
+            `Task: "${query}"\n\n` +
+            `Already included chunks:\n${currentSummary}\n\n` +
+            `${manifestSection}\n\n` +
+            `You are a code context expander. The search already found the "included" chunks above.\n` +
+            `Review the available chunks and select any that would help an AI agent complete the task.\n\n` +
+            `Rules:\n` +
+            `- STRONGLY PREFER dependency chunks — they are structurally connected to the search results via imports\n` +
+            `- Select type definitions, interfaces, models, or configs needed to understand included code\n` +
+            `- Select initialization or setup code if the task involves debugging or modifying a feature\n` +
+            `- Do NOT select test files, documentation, or unrelated utilities\n` +
+            `- Be selective: only include chunks that fill clear gaps. Quality over quantity.\n` +
+            `- If nothing useful is available, return an empty ids array\n\n` +
+            `Respond with ONLY a JSON object:\n` +
+            `{ "ids": [42, 17, 89], "note": "Brief 1-2 sentence observation about the codebase relevant to the task" }\n\n` +
+            `The "note" is optional — use it to mention things like missing files, architectural patterns, ` +
+            `deprecated modules, or important relationships you noticed. If nothing notable, omit it.\n` +
+            `If nothing to add: { "ids": [] }`;
+
+        try {
+            const response = await fetch('https://api.anthropic.com/v1/messages', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this._apiKey,
+                    'anthropic-version': '2023-06-01',
+                },
+                body: JSON.stringify({
+                    model: this._model,
+                    max_tokens: 512,
+                    messages: [{
+                        role: 'user',
+                        content: prompt,
+                    }],
+                }),
+            });
+
+            if (!response.ok) {
+                return { ids: [] };
+            }
+
+            const data = await response.json() as {
+                content: { type: string; text: string }[];
+            };
+
+            const text = data.content?.[0]?.text ?? '';
+            return this._parseResponse(text, available);
+        } catch {
+            return { ids: [] };
+        }
+    }
+
+    /** Parse Haiku response — handles both `{ ids, note }` and bare `[...]` formats. */
+    private _parseResponse(text: string, available: ExpanderManifestItem[]): ExpanderResult {
+        const validIds = new Set(available.map(m => m.id));
+
+        // Try JSON object first: { "ids": [...], "note": "..." }
+        const objMatch = text.match(/\{[\s\S]*"ids"\s*:\s*\[[\d\s,]*\][\s\S]*\}/);
+        if (objMatch) {
+            try {
+                const parsed = JSON.parse(objMatch[0]) as { ids: number[]; note?: string };
+                const ids = parsed.ids.filter(id => validIds.has(id));
+                const note = parsed.note?.trim() || undefined;
+                return { ids, note };
+            } catch {
+                // Fall through to array parsing
+            }
+        }
+
+        // Fallback: bare array [42, 17, 89]
+        const arrMatch = text.match(/\[[\d\s,]*\]/);
+        if (arrMatch) {
+            const ids = (JSON.parse(arrMatch[0]) as number[]).filter(id => validIds.has(id));
+            return { ids };
+        }
+
+        return { ids: [] };
+    }
+
+    async close(): Promise<void> {
+        // No resources to release (stateless HTTP)
+    }
+}

package/src/providers/pruners/haiku-pruner.ts

@@ -0,0 +1,112 @@
+/**
+ * BrainBank — Haiku Pruner
+ *
+ * LLM-based noise filter using Anthropic's Haiku 4.5 model.
+ * Binary classification: for each search result, Haiku decides
+ * "relevant" or "noise" based on filePath, metadata, and full
+ * file content (capped at ~8K chars per item by prune.ts).
+ *
+ * Latency: ~300-600ms.
+ */
+
+import type { Pruner, PrunerItem } from '@/types.ts';
+
+const DEFAULT_MODEL = 'claude-haiku-4-5-20251001';
+
+export interface HaikuPrunerOptions {
+    /** Anthropic API key. Falls back to ANTHROPIC_API_KEY env var. */
+    apiKey?: string;
+    /** Model to use. Default: claude-haiku-4-5-20251001 */
+    model?: string;
+}
+
+export class HaikuPruner implements Pruner {
+    private readonly _apiKey: string;
+    private readonly _model: string;
+
+    constructor(options: HaikuPrunerOptions = {}) {
+        this._apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY ?? '';
+        this._model = options.model ?? DEFAULT_MODEL;
+
+        if (!this._apiKey) {
+            throw new Error(
+                'HaikuPruner: No API key provided. Set ANTHROPIC_API_KEY env var or pass apiKey option.',
+            );
+        }
+    }
+
+    async prune(query: string, items: PrunerItem[]): Promise<number[]> {
+        if (items.length === 0) return [];
+        if (items.length === 1) return [items[0].id];
+
+        const itemLines = items.map(item => {
+            // Only show useful metadata fields (skip raw scores, IDs, large arrays)
+            const SKIP_KEYS = new Set(['id', 'chunkIds', 'rrfScore', 'filePath']);
+            const meta = Object.entries(item.metadata)
+                .filter(([k, v]) => v !== undefined && v !== null && !SKIP_KEYS.has(k))
+                .map(([k, v]) => `${k}=${v}`)
+                .join(' | ');
+            return `#${item.id} ${item.filePath} | ${meta}\n${item.preview}`;
+        }).join('\n---\n');
+
+        const prompt =
+            `Query: "${query}"\n\nSearch results (full file content):\n${itemLines}\n\n` +
+            `You are a precision search filter and ranker. You have the FULL source code of each file.\n` +
+            `Return a JSON array of #IDs to KEEP, ordered by relevance (most relevant FIRST).\n\n` +
+            `Rules:\n` +
+            `- Understand the SPECIFIC system/feature the query targets. Don't match on shared vocabulary alone.\n` +
+            `  Example: "snackbar toast notification" targets the toast popup system, NOT a notification center/bell icon.\n` +
+            `- KEEP files that directly implement, define types for, or configure the queried system.\n` +
+            `- KEEP files where the queried system is mounted, initialized, or composed into a workflow.\n` +
+            `- DROP files that only CONSUME the system (e.g. a component that calls showNotification once but has 400 lines of unrelated logic).\n` +
+            `- DROP files that implement a DIFFERENT system sharing similar vocabulary.\n` +
+            `- DROP infrastructure/boilerplate (font loaders, theme definitions, CSS-only layout shells) unless they directly configure the queried feature.\n` +
+            `- Aim for 40-70% keep rate. Returning fewer, highly relevant files is BETTER than returning many tangential ones.\n` +
+            `- ORDER: core implementation → types/config → mount points → peripheral.\n\n` +
+            `Respond with ONLY the JSON array. Example: [3, 0, 5, 1]`;
+
+        try {
+            const response = await fetch('https://api.anthropic.com/v1/messages', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this._apiKey,
+                    'anthropic-version': '2023-06-01',
+                },
+                body: JSON.stringify({
+                    model: this._model,
+                    max_tokens: 512,
+                    messages: [{
+                        role: 'user',
+                        content: prompt,
+                    }],
+                }),
+            });
+
+            if (!response.ok) {
+                // API error → fail-open, return all
+                return items.map(i => i.id);
+            }
+
+            const data = await response.json() as {
+                content: { type: string; text: string }[];
+            };
+
+            const text = data.content?.[0]?.text ?? '';
+            // Haiku may wrap in ```json ... ``` — extract any JSON array
+            const match = text.match(/\[[\d\s,]+\]/);
+            if (!match) return items.map(i => i.id);
+
+            const keepIds = JSON.parse(match[0]) as number[];
+            const validIds = new Set(items.map(i => i.id));
+            return keepIds.filter(id => validIds.has(id));
+        } catch {
+            // Network error → fail-open, return all
+            return items.map(i => i.id);
+        }
+    }
+
+    async close(): Promise<void> {
+        // No resources to release (stateless HTTP)
+    }
+}

package/src/providers/vector/hnsw-index.ts

@@ -0,0 +1,174 @@
+/**
+ * BrainBank — HNSW Vector Index
+ * 
+ * Wraps hnswlib-node for O(log n) approximate nearest neighbor search.
+ * M=16 connections, ef=200 construction, ef=50 search by default.
+ * 150x faster than brute force at 1M vectors.
+ *
+ * Supports disk persistence: save(path) / tryLoad(path, count)
+ * to skip costly vector-by-vector rebuild on startup.
+ */
+
+import type { VectorIndex, SearchHit } from '@/types.ts';
+
+import { existsSync } from 'node:fs';
+
+/** Shape of the HNSW index from hnswlib-node. */
+interface HnswlibIndex {
+    initIndex(maxElements: number, M: number, efConstruction: number): void;
+    setEf(ef: number): void;
+    addPoint(vector: number[], id: number): void;
+    markDelete(id: number): void;
+    searchKnn(vector: number[], k: number): { neighbors: number[]; distances: number[] };
+    writeIndexSync(path: string): void;
+    readIndexSync(path: string): void;
+    getCurrentCount(): number;
+    getIdsList(): number[];
+}
+
+/** Shape of the hnswlib-node module (supports default + named exports). */
+interface HnswlibModule {
+    default?: { HierarchicalNSW: new (space: 'cosine' | 'l2' | 'ip', dims: number) => HnswlibIndex };
+    HierarchicalNSW?: new (space: 'cosine' | 'l2' | 'ip', dims: number) => HnswlibIndex;
+}
+
+export class HNSWIndex implements VectorIndex {
+    private _index: HnswlibIndex | null = null;
+    private _lib: HnswlibModule | null = null;
+    private _ids = new Set<number>();
+
+    constructor(
+        private _dims: number,
+        private _maxElements: number = 2_000_000,
+        private _M: number = 16,
+        private _efConstruction: number = 200,
+        private _efSearch: number = 50,
+    ) {}
+
+    /**
+     * Initialize the HNSW index.
+     * Must be called before add/search.
+     */
+    async init(): Promise<this> {
+        this._lib = await import('hnswlib-node');
+        this._createIndex();
+        return this;
+    }
+
+    /**
+     * Reinitialize the index in-place, clearing all vectors.
+     * Required after reembed or full re-index to avoid duplicate IDs.
+     * init() must have been called first.
+     */
+    reinit(): void {
+        if (!this._lib) throw new Error('HNSW not initialized — call init() first');
+        this._createIndex();
+    }
+
+    private _createIndex(): void {
+        if (!this._lib) throw new Error('HNSW lib not loaded');
+        const HNSW = this._lib.default?.HierarchicalNSW ?? this._lib.HierarchicalNSW;
+        if (!HNSW) throw new Error('HierarchicalNSW not found in hnswlib-node module');
+        this._index = new HNSW('cosine', this._dims);
+        this._index.initIndex(this._maxElements, this._M, this._efConstruction);
+        this._index.setEf(this._efSearch);
+        this._ids = new Set();
+    }
+
+    /** Maximum capacity of this index. */
+    get maxElements(): number { return this._maxElements; }
+
+    /**
+     * Add a vector with an integer ID.
+     * The vector should be pre-normalized for cosine distance.
+     */
+    add(vector: Float32Array, id: number): void {
+        if (!this._index) throw new Error('HNSW index not initialized — call init() first');
+        if (this._ids.has(id)) return; // idempotent: skip duplicates
+        if (this._ids.size >= this._maxElements) {
+            throw new Error(
+                `HNSW index full (${this._maxElements} elements). ` +
+                `Increase maxElements in config or prune old data.`
+            );
+        }
+        this._index.addPoint(Array.from(vector), id);
+        this._ids.add(id);
+    }
+
+    /**
+     * Mark a vector as deleted so it no longer appears in searches.
+     * Uses hnswlib-node markDelete under the hood.
+     * Safe to call with an ID that doesn't exist.
+     */
+    remove(id: number): void {
+        if (!this._index || this._ids.size === 0) return;
+        if (!this._ids.has(id)) return;
+        try {
+            this._index.markDelete(id);
+            this._ids.delete(id);
+        } catch {
+            // ID not found — ignore silently
+        }
+    }
+
+    /**
+     * Search for the k nearest neighbors.
+     * Returns results sorted by score (highest first).
+     * Score is 1 - cosine_distance (1.0 = identical).
+     */
+    search(query: Float32Array, k: number): SearchHit[] {
+        if (!this._index || this._ids.size === 0) return [];
+
+        const actualK = Math.min(k, this._ids.size);
+        const result = this._index.searchKnn(Array.from(query), actualK);
+
+        return result.neighbors.map((id: number, i: number) => ({
+            id,
+            score: 1 - result.distances[i],
+        }));
+    }
+
+    /** Number of vectors in the index. */
+    get size(): number {
+        return this._ids.size;
+    }
+
+    /**
+     * Save the HNSW graph to disk.
+     * The file can be loaded later with tryLoad() to skip vector-by-vector insertion.
+     */
+    save(path: string): void {
+        if (!this._index || this._ids.size === 0) return;
+        this._index.writeIndexSync(path);
+    }
+
+    /**
+     * Try to load a previously saved HNSW index from disk.
+     * Returns true if loaded successfully, false if stale or missing.
+     * @param path File path to the saved index
+     * @param expectedCount Expected number of vectors (from SQLite) — used to detect staleness
+     */
+    tryLoad(path: string, expectedCount: number): boolean {
+        if (!this._index || !existsSync(path)) return false;
+
+        try {
+            this._index.readIndexSync(path);
+            const loadedCount = this._index.getCurrentCount();
+
+            // Stale: vector count in DB differs from saved index
+            if (loadedCount !== expectedCount) {
+                this.reinit();
+                return false;
+            }
+
+            // Rebuild _ids set from the loaded index
+            const ids = this._index.getIdsList();
+            this._ids = new Set(ids);
+            this._index.setEf(this._efSearch);
+            return true;
+        } catch {
+            this.reinit();
+            return false;
+        }
+    }
+}

package/src/providers/vector/hnsw-loader.ts

@@ -0,0 +1,129 @@
+/**
+ * BrainBank — HNSW Loader
+ *
+ * Utilities for persisting and loading HNSW indexes to/from disk.
+ * Used by BrainBank._runInitialize() and PluginContext.loadVectors().
+ *
+ * Includes cross-process write locking and hot-reload support
+ * for multi-process coordination.
+ */
+
+import type { DatabaseAdapter, CountRow } from '@/db/adapter.ts';
+import type { HNSWIndex } from './hnsw-index.ts';
+
+import { dirname, join } from 'node:path';
+import { withLock } from '@/lib/write-lock.ts';
+
+/** Derive the HNSW index file path from the DB path. */
+export function hnswPath(dbPath: string, name: string): string {
+    return join(dirname(dbPath), `hnsw-${name}.index`);
+}
+
+/** Derive the lock directory from the DB path. */
+export function lockDir(dbPath: string): string {
+    return dirname(dbPath);
+}
+
+/** Count rows in a vector table (fast, no data transfer). */
+export function countRows(db: DatabaseAdapter, table: string): number {
+    const row = db.prepare(`SELECT COUNT(*) as c FROM ${table}`).get() as CountRow;
+    return row?.c ?? 0;
+}
+
+/**
+ * Save all HNSW indexes to disk with cross-process file locking.
+ * Prevents concurrent writes from corrupting `.index` files.
+ */
+export async function saveAllHnsw(
+    dbPath: string,
+    kvHnsw: HNSWIndex,
+    sharedHnsw: Map<string, { hnsw: HNSWIndex; vecCache: Map<number, Float32Array> }>,
+    privateHnsw: Map<string, HNSWIndex>,
+): Promise<boolean> {
+    try {
+        await withLock(lockDir(dbPath), 'hnsw', () => {
+            kvHnsw.save(hnswPath(dbPath, 'kv'));
+            for (const [name, { hnsw }] of sharedHnsw) {
+                hnsw.save(hnswPath(dbPath, name));
+            }
+            for (const [name, hnsw] of privateHnsw) {
+                hnsw.save(hnswPath(dbPath, name));
+            }
+        });
+        return true;
+    } catch {
+        // Non-fatal: next startup rebuilds from SQLite (slower).
+        return false;
+    }
+}
+
+/** Load vectors from SQLite into HNSW + cache. */
+export function loadVectors(
+    db: DatabaseAdapter,
+    table: string,
+    idCol: string,
+    hnsw: HNSWIndex,
+    cache: Map<number, Float32Array>,
+): void {
+    const iter = db.prepare(`SELECT ${idCol}, embedding FROM ${table}`).iterate() as IterableIterator<{ embedding: Uint8Array; [key: string]: unknown }>;
+    for (const row of iter) {
+        const vec = new Float32Array(
+            row.embedding.buffer.slice(
+                row.embedding.byteOffset,
+                row.embedding.byteOffset + row.embedding.byteLength,
+            ),
+        );
+        hnsw.add(vec, row[idCol] as number);
+        cache.set(row[idCol] as number, vec);
+    }
+}
+
+/** Populate only the vecCache from SQLite (HNSW already loaded from file). */
+export function loadVecCache(
+    db: DatabaseAdapter,
+    table: string,
+    idCol: string,
+    cache: Map<number, Float32Array>,
+): void {
+    const iter = db.prepare(`SELECT ${idCol}, embedding FROM ${table}`).iterate() as IterableIterator<{ embedding: Uint8Array; [key: string]: unknown }>;
+    for (const row of iter) {
+        const vec = new Float32Array(
+            row.embedding.buffer.slice(
+                row.embedding.byteOffset,
+                row.embedding.byteOffset + row.embedding.byteLength,
+            ),
+        );
+        cache.set(row[idCol] as number, vec);
+    }
+}
+
+/** Deps for reloading a single HNSW index from disk. */
+interface ReloadDeps {
+    dbPath: string;
+    db: DatabaseAdapter;
+    name: string;
+    hnsw: HNSWIndex;
+    vecCache: Map<number, Float32Array>;
+    vectorTable: string;
+    idCol: string;
+}
+
+/**
+ * Reload a single HNSW index from disk after detecting a stale version.
+ * Reinitializes the in-memory HNSW, loads the saved index file, and
+ * refreshes the vector cache from SQLite.
+ */
+export function reloadHnsw(deps: ReloadDeps): void {
+    const { dbPath, db, name, hnsw, vecCache, vectorTable, idCol } = deps;
+    const indexPath = hnswPath(dbPath, name);
+    const rowCount = countRows(db, vectorTable);
+
+    hnsw.reinit();
+    vecCache.clear();
+
+    if (hnsw.tryLoad(indexPath, rowCount)) {
+        loadVecCache(db, vectorTable, idCol, vecCache);
+    } else {
+        loadVectors(db, vectorTable, idCol, hnsw, vecCache);
+    }
+}

package/src/search/bm25-boost.ts

@@ -0,0 +1,69 @@
+/**
+ * BrainBank — BM25 Intersection Boost
+ *
+ * Pure functions for post-processing vector search results with BM25 keyword overlap.
+ * Extracted from ContextBuilder for single-responsibility and testability.
+ */
+
+import type { SearchResult } from '@/types.ts';
+import type { SearchStrategy } from './types.ts';
+
+/** BM25 boost factor applied to vector results that also match keywords. */
+export const BM25_BOOST = 0.15;
+
+/**
+ * Boost vector results that also appear in BM25 keyword results.
+ * Does NOT add new results — only re-scores and re-sorts existing vector hits.
+ * This promotes keyword-relevant files without introducing BM25-only noise.
+ */
+export async function boostWithBM25(
+    vectorResults: SearchResult[],
+    bm25: SearchStrategy,
+    query: string,
+    sources: Record<string, number>,
+): Promise<SearchResult[]> {
+    if (vectorResults.length === 0) return vectorResults;
+
+    const bm25Results = await bm25.search(query, { sources });
+    if (bm25Results.length === 0) return vectorResults;
+
+    // Build a set of BM25 hit keys for fast lookup
+    const bm25Keys = new Set<string>();
+    for (const r of bm25Results) {
+        bm25Keys.add(resultKey(r));
+    }
+
+    // Boost scores of vector results that also appear in BM25
+    const boosted = vectorResults.map(r => {
+        const k = resultKey(r);
+        if (bm25Keys.has(k)) {
+            return { ...r, score: r.score + BM25_BOOST };
+        }
+        return r;
+    });
+
+    // Re-sort by boosted score
+    boosted.sort((a, b) => b.score - a.score);
+    return boosted;
+}
+
+/** Filter results whose filePath starts with any of the given prefixes. */
+export function filterByPath(results: SearchResult[], prefix: string | string[] | undefined): SearchResult[] {
+    if (!prefix) return results;
+    const prefixes = Array.isArray(prefix) ? prefix : [prefix];
+    if (prefixes.length === 0) return results;
+    return results.filter(r => prefixes.some(p => r.filePath?.startsWith(p)));
+}
+
+/** Exclude results whose filePath starts with any of the given prefixes. */
+export function filterByIgnore(results: SearchResult[], ignorePaths: string[] | undefined): SearchResult[] {
+    if (!ignorePaths || ignorePaths.length === 0) return results;
+    return results.filter(r => !r.filePath || !ignorePaths.some(p => r.filePath!.startsWith(p)));
+}
+
+/** Generate a dedup key for a search result (file:startLine:endLine). */
+export function resultKey(r: SearchResult): string {
+    const sl = 'startLine' in r.metadata ? r.metadata.startLine : '';
+    const el = 'endLine' in r.metadata ? r.metadata.endLine : '';
+    return `${r.filePath ?? ''}:${sl}:${el}`;
+}