opencode-rag-plugin 1.15.1 → 1.17.0

package/dist/retriever/retriever.js

@@ -2,6 +2,9 @@
  *  We request extra results up-front, then after hybrid fusion + minScore filtering,
  *  we slice back to the requested topK. */
 const FETCH_OVERFETCH_FACTOR = 3;
+const RRF_K = 60;
+/** Multiply raw RRF scores by (K+1) to normalize to ~[0,1]. */
+const RRF_NORMALIZE = RRF_K + 1;
 /**
  * Perform hybrid vector-keyword retrieval with configurable scoring.
  *
@@ -28,13 +31,13 @@ export async function retrieve(query, embedder, store, options = {}) {
         if (typeof embedding[0] !== "number") {
             return [];
         }
-        const vectorResults = await store.search(embedding, topK * FETCH_OVERFETCH_FACTOR);
+        const vectorResults = await store.searchWithFilter(embedding, topK * FETCH_OVERFETCH_FACTOR, options.filter);
         let keywordResults = [];
-        if (options.keywordIndex) {
-            keywordResults = options.keywordIndex.search(query, topK * FETCH_OVERFETCH_FACTOR);
+        if (options.keywordIndex && options.hybridEnabled !== false) {
+            keywordResults = options.keywordIndex.search(query, topK * FETCH_OVERFETCH_FACTOR, options.filter);
         }
         if (keywordResults.length === 0) {
-            const filtered = vectorResults.filter((r) => r.score >= minScore);
+            const filtered = vectorResults.filter((r) => r.score >= minScore).slice(0, topK);
             if (options.explain) {
                 const kw = options.keywordWeight ?? 0.4;
                 for (const r of filtered) {
@@ -51,65 +54,40 @@ export async function retrieve(query, embedder, store, options = {}) {
             }
             return filtered;
         }
-        const kwTopScore = keywordResults.length > 0 ? keywordResults[0].score : 1;
-        const combined = new Map();
-        for (const r of vectorResults) {
-            combined.set(r.chunk.id, {
-                chunk: r.chunk,
-                vScore: r.score,
-                kScore: 0,
-                rawVScore: r.score,
-                rawKScore: 0,
-            });
-        }
-        for (const r of keywordResults) {
-            const existing = combined.get(r.chunk.id);
-            const normalizedK = kwTopScore > 0 ? r.score / kwTopScore : 0;
-            if (existing) {
-                existing.kScore = normalizedK;
-                existing.rawKScore = r.score;
-            }
-            else {
-                combined.set(r.chunk.id, {
-                    chunk: r.chunk,
-                    vScore: 0,
-                    kScore: normalizedK,
-                    rawVScore: 0,
-                    rawKScore: r.score,
-                });
-            }
-        }
+        const vRank = new Map(vectorResults.map((r, i) => [r.chunk.id, i]));
+        const kRank = new Map(keywordResults.map((r, i) => [r.chunk.id, i]));
+        const chunkById = new Map();
+        for (const r of vectorResults)
+            chunkById.set(r.chunk.id, r);
+        for (const r of keywordResults)
+            if (!chunkById.has(r.chunk.id))
+                chunkById.set(r.chunk.id, r);
         const kw = options.keywordWeight ?? 0.4;
-        const combinedResults = [...combined.values()]
-            .map((entry) => {
-            const hasVector = entry.vScore > 0;
-            const hasKeyword = entry.kScore > 0;
-            const score = hasVector && hasKeyword
-                ? (1 - kw) * entry.vScore + kw * entry.kScore
-                : hasVector
-                    ? entry.vScore
-                    : entry.kScore * 0.9;
-            const result = {
-                chunk: entry.chunk,
-                score,
-            };
+        const allIds = new Set([...vRank.keys(), ...kRank.keys()]);
+        const combinedResults = [...allIds].map((id) => {
+            const vR = vRank.get(id);
+            const kR = kRank.get(id);
+            const vContrib = vR !== undefined ? ((1 - kw) * RRF_NORMALIZE) / (RRF_K + vR + 1) : 0;
+            const kContrib = kR !== undefined ? (kw * RRF_NORMALIZE) / (RRF_K + kR + 1) : 0;
+            const score = vContrib + kContrib;
+            const result = { chunk: chunkById.get(id).chunk, score };
             if (options.explain) {
-                const explanation = {
+                result.explanation = {
                     scoreBreakdown: {
-                        vectorScore: entry.vScore,
-                        keywordScore: entry.kScore,
-                        rawVectorScore: entry.rawVScore,
-                        rawKeywordScore: entry.rawKScore,
+                        vectorScore: vContrib,
+                        keywordScore: kContrib,
+                        rawVectorScore: vR !== undefined ? vectorResults[vR].score : 0,
+                        rawKeywordScore: kR !== undefined ? keywordResults[kR].score : 0,
                         keywordWeight: kw,
+                        vectorRank: vR,
+                        keywordRank: kR,
                     },
                 };
-                if (options.keywordIndex && entry.rawKScore > 0) {
-                    const terms = options.keywordIndex.getMatchedTerms(query, entry.chunk.id);
-                    if (terms.length > 0) {
-                        explanation.matchedTerms = terms;
-                    }
+                if (options.keywordIndex && kR !== undefined) {
+                    const terms = options.keywordIndex.getMatchedTerms(query, id);
+                    if (terms.length > 0)
+                        result.explanation.matchedTerms = terms;
                 }
-                result.explanation = explanation;
             }
             return result;
         })

package/dist/vectorstore/lancedb.d.ts

@@ -1,4 +1,9 @@
-import type { VectorStore, Chunk, SearchResult } from "../core/interfaces.js";
+import type { VectorStore, Chunk, SearchResult, MetadataFilter } from "../core/interfaces.js";
+/**
+ * L2-normalize a vector to unit length. Cosine models require unit vectors
+ * for the dot product to equal cosine similarity.
+ */
+export declare function l2Normalize(vec: number[]): number[];
 /**
  * Check whether an error is a LanceDB corruption error (table not found / broken).
  * @param err - The error to inspect.
@@ -45,12 +50,13 @@ export declare class LanceDbStore implements VectorStore {
     private addChunksInternal;
     /**
      * Perform ANN (approximate nearest neighbor) search using LanceDB's native vector index.
-     * Returns results scored as 1 / (1 + L2 distance). Falls back to repair on corruption.
+     * Returns results scored as cosine similarity (0-1). Falls back to repair on corruption.
      * @param embedding - The query embedding vector.
      * @param topK - Maximum number of results to return.
      * @returns An array of search results sorted by descending score.
      */
     search(embedding: number[], topK: number): Promise<SearchResult[]>;
+    searchWithFilter(embedding: number[], topK: number, filter?: MetadataFilter): Promise<SearchResult[]>;
     private rowToSearchResult;
     /**
      * List all distinct file paths stored in the index, along with their language and chunk count.
@@ -82,12 +88,24 @@ export declare class LanceDbStore implements VectorStore {
         content: string;
         description: string;
     }[]>;
+    /**
+     * Perform ANN search internally, returning results scored as cosine similarity (0-1).
+     * This method is called by `search()` and handles the actual query logic.
+     * @param embedding - The query embedding vector.
+     * @param topK - The number of top results to return.
+     * @returns An array of search results with scores.
+     */
     private searchInternal;
     /**
      * Return the total number of chunks stored in the table.
      * @returns The chunk count, or 0 if the table does not exist.
      */
     count(): Promise<number>;
+    /**
+     * Return all unique file paths currently stored in the index.
+     * @returns An array of normalized file paths.
+     */
+    getFilePaths(): Promise<string[]>;
     /**
      * Re-open the store, optionally pointing at a new database path.
      * Closes any existing connection and resets internal state so that the
@@ -98,16 +116,29 @@ export declare class LanceDbStore implements VectorStore {
     reopen(newPath?: string): Promise<void>;
     /** Close the database connection and release resources. */
     close(): Promise<void>;
+    /**
+     * Back up the chunks.lance directory before a destructive operation.
+     * Creates a timestamped copy at chunks.lance.backup-<ISO timestamp>.
+     * Skips if chunks.lance doesn't exist or noBackup is set.
+     * @returns The backup path, or null if nothing was backed up.
+     */
+    private backupBeforeClear;
     /**
      * Remove all chunks by dropping the underlying LanceDB table.
      * Falls back to deleting the database directory if dropTable fails.
+     * @param options - Optional. Set `{ noBackup: true }` to skip backup (test use only).
      */
-    clear(): Promise<void>;
+    clear(options?: {
+        noBackup?: boolean;
+    }): Promise<void>;
     /**
      * Completely remove the entire LanceDB database directory from disk.
      * All data is permanently lost.
+     * @param options - Optional. Set `{ noBackup: true }` to skip backup (test use only).
      */
-    dropDatabase(): Promise<void>;
+    dropDatabase(options?: {
+        noBackup?: boolean;
+    }): Promise<void>;
     /**
      * Remove all chunks associated with a given file path.
      * Automatically attempts repair on corruption errors.

package/dist/vectorstore/lancedb.js

@@ -3,9 +3,23 @@
  */
 import * as lancedb from "@lancedb/lancedb";
 import fs from "node:fs/promises";
+import path from "node:path";
 import { normalizeFilePath, manifestPathFor } from "../core/manifest.js";
 const TABLE_NAME = "chunks";
 const QUERY_COLUMNS = ["id", "content", "description", "filePath", "startLine", "endLine", "language"];
+/**
+ * L2-normalize a vector to unit length. Cosine models require unit vectors
+ * for the dot product to equal cosine similarity.
+ */
+export function l2Normalize(vec) {
+    let norm = 0;
+    for (const v of vec)
+        norm += v * v;
+    norm = Math.sqrt(norm);
+    if (norm === 0)
+        return vec;
+    return vec.map((v) => v / norm);
+}
 /**
  * Check whether an error is a LanceDB corruption error (table not found / broken).
  * @param err - The error to inspect.
@@ -189,7 +203,7 @@ export class LanceDbStore {
             id: c.id,
             content: c.content,
             description: c.description ?? "",
-            embedding: c.embedding,
+            embedding: l2Normalize(c.embedding),
             filePath: normalizeFilePath(c.metadata.filePath),
             startLine: c.metadata.startLine,
             endLine: c.metadata.endLine,
@@ -213,15 +227,17 @@ export class LanceDbStore {
         await table.add(rows);
         // THEN DEDUP: remove old rows at the same (filePath, startLine) positions,
         // but preserve the newly inserted rows by filtering out their IDs.
+        // IMPORTANT: use a single NOT IN clause per position so that when multiple
+        // new IDs share the same startLine they don't delete each other.
         for (const [key, newIds] of newIdsByLine) {
             const colonIdx = key.lastIndexOf(":");
             const filePath = key.slice(0, colonIdx);
             const startLine = parseInt(key.slice(colonIdx + 1), 10);
             const escapedPath = filePath.replace(/'/g, "''");
-            for (const id of newIds) {
-                const escapedId = id.replace(/'/g, "''");
-                await table.delete(`filePath = '${escapedPath}' AND startLine = ${startLine} AND id != '${escapedId}'`);
-            }
+            const idList = [...newIds]
+                .map((id) => `'${id.replace(/'/g, "''")}'`)
+                .join(", ");
+            await table.delete(`filePath = '${escapedPath}' AND startLine = ${startLine} AND id NOT IN (${idList})`);
         }
         // FINALLY: remove stale chunks for the same file that belong to a
         // previous revision (different startLines).  Exclude the new inserts
@@ -247,20 +263,23 @@ export class LanceDbStore {
     }
     /**
      * Perform ANN (approximate nearest neighbor) search using LanceDB's native vector index.
-     * Returns results scored as 1 / (1 + L2 distance). Falls back to repair on corruption.
+     * Returns results scored as cosine similarity (0-1). Falls back to repair on corruption.
      * @param embedding - The query embedding vector.
      * @param topK - Maximum number of results to return.
      * @returns An array of search results sorted by descending score.
      */
     async search(embedding, topK) {
+        return this.searchWithFilter(embedding, topK);
+    }
+    async searchWithFilter(embedding, topK, filter) {
         try {
-            return await this.searchInternal(embedding, topK);
+            return await this.searchInternal(embedding, topK, filter);
         }
         catch (err) {
             if (isCorruptionError(err)) {
                 const repaired = await this.tryRepair();
                 if (repaired) {
-                    return this.searchInternal(embedding, topK);
+                    return this.searchInternal(embedding, topK, filter);
                 }
             }
             return [];
@@ -268,7 +287,7 @@ export class LanceDbStore {
     }
     rowToSearchResult(row) {
         return {
-            score: 1 / (1 + (row._distance ?? 0)),
+            score: Math.min(1, Math.max(0, 1 - (row._distance ?? 0) / 2)),
             chunk: {
                 id: row.id,
                 content: row.content,
@@ -357,7 +376,14 @@ export class LanceDbStore {
             description: row.description ?? "",
         }));
     }
-    async searchInternal(embedding, topK) {
+    /**
+     * Perform ANN search internally, returning results scored as cosine similarity (0-1).
+     * This method is called by `search()` and handles the actual query logic.
+     * @param embedding - The query embedding vector.
+     * @param topK - The number of top results to return.
+     * @returns An array of search results with scores.
+     */
+    async searchInternal(embedding, topK, filter) {
         const db = await this.getDb();
         const tableNames = await db.tableNames();
         if (!tableNames.includes(TABLE_NAME))
@@ -366,7 +392,11 @@ export class LanceDbStore {
         const count = await table.countRows();
         if (count === 0)
             return [];
-        const results = await table.search(embedding).limit(topK).toArray();
+        let query = table.vectorSearch(l2Normalize(embedding)).distanceType("cosine");
+        const whereClause = buildWhereClause(filter);
+        if (whereClause)
+            query = query.where(whereClause);
+        const results = await query.limit(topK).toArray();
         return results
             .map((row) => this.rowToSearchResult(row))
             .filter((r) => r.chunk.id !== "__seed__");
@@ -388,6 +418,30 @@ export class LanceDbStore {
             return 0;
         }
     }
+    /**
+     * Return all unique file paths currently stored in the index.
+     * @returns An array of normalized file paths.
+     */
+    async getFilePaths() {
+        try {
+            const db = await this.getDb();
+            const tableNames = await db.tableNames();
+            if (!tableNames.includes(TABLE_NAME))
+                return [];
+            const table = await this.getTable();
+            const rows = await table.query().select(["filePath"]).toArray();
+            const paths = new Set();
+            for (const row of rows) {
+                const fp = row.filePath;
+                if (fp)
+                    paths.add(fp);
+            }
+            return Array.from(paths);
+        }
+        catch {
+            return [];
+        }
+    }
     /**
      * Re-open the store, optionally pointing at a new database path.
      * Closes any existing connection and resets internal state so that the
@@ -396,24 +450,52 @@ export class LanceDbStore {
      * @param newPath - Optional new filesystem path for the LanceDB database.
      */
     async reopen(newPath) {
-        if (newPath)
-            this.dbPath = newPath;
+        await this.table?.close();
+        await this.db?.close();
         this.table = null;
         this.db = null;
         this.tableInit = null;
+        if (newPath)
+            this.dbPath = newPath;
     }
     /** Close the database connection and release resources. */
     async close() {
-        this.table?.close();
+        await this.table?.close();
         this.table = null;
-        this.db?.close();
+        await this.db?.close();
         this.db = null;
     }
+    /**
+     * Back up the chunks.lance directory before a destructive operation.
+     * Creates a timestamped copy at chunks.lance.backup-<ISO timestamp>.
+     * Skips if chunks.lance doesn't exist or noBackup is set.
+     * @returns The backup path, or null if nothing was backed up.
+     */
+    async backupBeforeClear(noBackup) {
+        if (noBackup)
+            return null;
+        const lancePath = path.join(this.dbPath, "chunks.lance");
+        try {
+            await fs.access(lancePath);
+        }
+        catch {
+            return null;
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const backupPath = `${lancePath}.backup-${timestamp}`;
+        await fs.cp(lancePath, backupPath, { recursive: true });
+        return backupPath;
+    }
     /**
      * Remove all chunks by dropping the underlying LanceDB table.
      * Falls back to deleting the database directory if dropTable fails.
+     * @param options - Optional. Set `{ noBackup: true }` to skip backup (test use only).
      */
-    async clear() {
+    async clear(options) {
+        const backup = await this.backupBeforeClear(options?.noBackup);
+        if (backup)
+            console.warn(`[lancedb] Backed up chunks.lance to ${backup}`);
+        await this.table?.close();
         this.table = null;
         try {
             const db = await this.getDb();
@@ -421,8 +503,11 @@ export class LanceDbStore {
             if (tableNames.includes(TABLE_NAME)) {
                 await db.dropTable(TABLE_NAME);
             }
+            await this.db?.close();
+            this.db = null;
         }
         catch {
+            await this.db?.close();
             this.db = null;
             try {
                 await fs.rm(this.dbPath, { recursive: true, force: true });
@@ -433,8 +518,27 @@ export class LanceDbStore {
     /**
      * Completely remove the entire LanceDB database directory from disk.
      * All data is permanently lost.
+     * @param options - Optional. Set `{ noBackup: true }` to skip backup (test use only).
      */
-    async dropDatabase() {
+    async dropDatabase(options) {
+        if (!options?.noBackup) {
+            // Back up the entire store directory since dropDatabase deletes it.
+            try {
+                await fs.access(this.dbPath);
+            }
+            catch {
+                // nothing to back up
+            }
+            try {
+                const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+                const backupPath = `${this.dbPath}.backup-${timestamp}`;
+                await fs.cp(this.dbPath, backupPath, { recursive: true });
+                console.warn(`[lancedb] Backed up database to ${backupPath}`);
+            }
+            catch {
+                // backup failed, continue anyway
+            }
+        }
         this.table = null;
         this.db = null;
         try {
@@ -481,8 +585,6 @@ export class LanceDbStore {
                 table = await db.openTable(TABLE_NAME);
             }
             catch {
-                // Table is corrupt and can't even be opened — leave it be so the user
-                // can run `opencode-rag index --force` to rebuild with full control.
                 console.error("[lancedb] Corrupt table detected. Run 'opencode-rag index --force' to rebuild.");
                 return false;
             }
@@ -491,13 +593,10 @@ export class LanceDbStore {
                 versions = await table.listVersions();
             }
             catch {
-                // Can't list versions (corrupt version manifest). Don't nuke data —
-                // let the user decide how to proceed.
                 console.warn("[lancedb] Could not list table versions for repair. " +
                     "Run 'opencode-rag index --force' to rebuild if search results are incorrect.");
                 return false;
             }
-            // No previous version to roll back to — not a corruption we can fix.
             if (versions.length <= 1) {
                 return false;
             }
@@ -515,7 +614,6 @@ export class LanceDbStore {
                     continue;
                 }
             }
-            // Tried all versions, none worked — report failure but don't destroy data.
             console.error("[lancedb] All version-restore attempts failed. " +
                 "Run 'opencode-rag index --force' to rebuild the index.");
             return false;
@@ -525,4 +623,29 @@ export class LanceDbStore {
         }
     }
 }
+/**
+ * Build a LanceDB SQL WHERE clause from a MetadataFilter.
+ * Handles path glob patterns and language filters with proper escaping.
+ */
+function buildWhereClause(filter) {
+    if (!filter)
+        return undefined;
+    const parts = [];
+    if (filter.languages?.length) {
+        const langs = filter.languages.map((l) => `'${l.replace(/'/g, "''")}'`).join(",");
+        parts.push(`language IN (${langs})`);
+    }
+    if (filter.pathPatterns?.length) {
+        const likes = filter.pathPatterns.map((p) => {
+            const escaped = p.replace(/'/g, "''");
+            const like = escaped
+                .replace(/\*\*/g, "%")
+                .replace(/\*/g, "%")
+                .replace(/\?/g, "_");
+            return `filePath LIKE '${like}'`;
+        });
+        parts.push(`(${likes.join(" OR ")})`);
+    }
+    return parts.length ? parts.join(" AND ") : undefined;
+}
 //# sourceMappingURL=lancedb.js.map

package/dist/vectorstore/memory.d.ts

@@ -1,19 +1,24 @@
 /**
  * @fileoverview Ephemeral in-memory vector store using cosine similarity search.
  */
-import type { VectorStore, Chunk, SearchResult } from "../core/interfaces.js";
+import type { VectorStore, Chunk, ChunkSummary, FileSummary, SearchResult, MetadataFilter } from "../core/interfaces.js";
 /** Ephemeral in-memory vector store using cosine similarity search. */
 export declare class InMemoryVectorStore implements VectorStore {
     private chunks;
     addChunks(chunks: Chunk[]): Promise<void>;
     search(embedding: number[], topK: number): Promise<SearchResult[]>;
+    searchWithFilter(embedding: number[], topK: number, filter?: MetadataFilter): Promise<SearchResult[]>;
     count(): Promise<number>;
     clear(): Promise<void>;
+    getFilePaths(): Promise<string[]>;
     /**
      * Remove all chunks associated with a given file path.
      * @param filePath - The file path whose chunks should be removed.
      */
     deleteByFilePath(filePath: string): Promise<void>;
+    getChunks(offset: number, limit: number): Promise<ChunkSummary[]>;
+    listFiles(): Promise<FileSummary[]>;
+    getChunksByFilePath(filePath: string): Promise<Chunk[]>;
     /** Release any held resources. No-op for the in-memory store. */
     close(): Promise<void>;
 }

package/dist/vectorstore/memory.js

@@ -5,8 +5,12 @@ export class InMemoryVectorStore {
         this.chunks.push(...chunks.filter((c) => c.embedding && c.embedding.length > 0));
     }
     async search(embedding, topK) {
+        return this.searchWithFilter(embedding, topK);
+    }
+    async searchWithFilter(embedding, topK, filter) {
         const withEmbeddings = this.chunks.filter((c) => c.embedding !== undefined && c.embedding.length === embedding.length);
         const scored = withEmbeddings
+            .filter((c) => matchesFilter(c, filter))
             .map((chunk) => {
             const sim = cosineSimilarity(embedding, chunk.embedding);
             return { chunk, score: sim };
@@ -21,6 +25,10 @@ export class InMemoryVectorStore {
     async clear() {
         this.chunks = [];
     }
+    async getFilePaths() {
+        const paths = new Set(this.chunks.map((c) => c.metadata.filePath));
+        return Array.from(paths);
+    }
     /**
      * Remove all chunks associated with a given file path.
      * @param filePath - The file path whose chunks should be removed.
@@ -28,6 +36,37 @@ export class InMemoryVectorStore {
     async deleteByFilePath(filePath) {
         this.chunks = this.chunks.filter((c) => c.metadata.filePath !== filePath);
     }
+    async getChunks(offset, limit) {
+        return this.chunks.slice(offset, offset + limit).map((c) => ({
+            id: c.id,
+            filePath: c.metadata.filePath,
+            language: c.metadata.language,
+            startLine: c.metadata.startLine,
+            endLine: c.metadata.endLine,
+            content: c.content,
+            description: c.description ?? "",
+        }));
+    }
+    async listFiles() {
+        const fileMap = new Map();
+        for (const c of this.chunks) {
+            const existing = fileMap.get(c.metadata.filePath);
+            if (existing) {
+                existing.chunkCount++;
+            }
+            else {
+                fileMap.set(c.metadata.filePath, { language: c.metadata.language, chunkCount: 1 });
+            }
+        }
+        return Array.from(fileMap.entries())
+            .map(([filePath, info]) => ({ filePath, ...info }))
+            .sort((a, b) => a.filePath.localeCompare(b.filePath));
+    }
+    async getChunksByFilePath(filePath) {
+        return this.chunks
+            .filter((c) => c.metadata.filePath === filePath)
+            .sort((a, b) => a.metadata.startLine - b.metadata.startLine);
+    }
     /** Release any held resources. No-op for the in-memory store. */
     async close() {
     }
@@ -38,6 +77,25 @@ export class InMemoryVectorStore {
  * @param b - Second vector.
  * @returns The cosine similarity (0 if either vector has zero magnitude).
  */
+function globMatch(pattern, filePath) {
+    const GLOBSTAR = "\x00GS\x00";
+    let re = pattern.replace(/\*\*/g, GLOBSTAR);
+    re = re.replace(/([.+^${}()|[\]\\])/g, "\\$1");
+    re = re.replace(new RegExp(GLOBSTAR, "g"), ".*");
+    re = re.replace(/\*/g, "[^/]*");
+    re = re.replace(/\?/g, ".");
+    return new RegExp("^" + re + "$").test(filePath);
+}
+function matchesFilter(chunk, filter) {
+    if (!filter)
+        return true;
+    if (filter.languages?.length && !filter.languages.includes(chunk.metadata.language))
+        return false;
+    if (filter.pathPatterns?.length) {
+        return filter.pathPatterns.some((p) => globMatch(p, chunk.metadata.filePath));
+    }
+    return true;
+}
 function cosineSimilarity(a, b) {
     let dot = 0;
     let normA = 0;

package/dist/watcher.js

@@ -30,6 +30,7 @@ function writeWatcherStatus(storePath, status) {
 export function createBackgroundIndexer(options) {
     const { cwd, storePath, config, store, embedder, logFilePath, logLevel, keywordIndex, descriptionProvider } = options;
     writeWatcherStatus(storePath, { running: false, lastRunAt: undefined });
+    const ac = new AbortController();
     const updateStatus = (partial) => {
         writeWatcherStatus(storePath, { running: false, lastRunAt: undefined, ...partial });
     };
@@ -45,6 +46,7 @@ export function createBackgroundIndexer(options) {
                 keywordIndex,
                 descriptionProvider,
                 filterPaths,
+                abortSignal: ac.signal,
                 logger: {
                     info: (message) => appendDebugLog(logFilePath, { scope: "autoIndex", message }, logLevel),
                     warn: (message) => appendDebugLog(logFilePath, { scope: "autoIndex", message }, logLevel),
@@ -114,6 +116,7 @@ export function createBackgroundIndexer(options) {
         async close() {
             if (periodicTimer)
                 clearInterval(periodicTimer);
+            ac.abort();
             scheduler.close();
             await scheduler.waitForIdle();
             await watcher.close();