@wrongstack/tools 0.236.0 → 0.255.0

package/dist/codebase-index/index.d.ts

@@ -1,5 +1,5 @@
-import { I as IndexResult, S as Symbol, F as FileMeta, a as SymbolKind, b as SymbolLang, c as SearchResult, d as IndexStats, R as Ref } from '../background-indexer-CtbgPExj.js';
-export { e as FileSymbols, f as SCHEMA_VERSION, g as cancelPendingReindexes, h as codebaseIndexTool, i as codebaseSearchTool, j as codebaseStatsTool, k as enqueueReindex, l as getIndexState, m as isIndexReady, n as isIndexableFile, o as isIndexing, p as onIndexStateChange, r as runStartupIndex } from '../background-indexer-CtbgPExj.js';
+import { t as IndexResult, S as Symbol, F as FileMeta, u as SymbolKind, v as SymbolLang, w as SearchResult, x as IndexStats, R as Ref } from '../background-indexer-CJ5JiV5i.js';
+export { C as CircuitOpenError, a as CircuitSnapshot, b as CircuitState, y as FileSymbols, I as IndexCircuitBreaker, c as IndexTimeoutError, z as SCHEMA_VERSION, d as cancelPendingReindexes, e as codebaseIndexStats, f as codebaseIndexTool, g as codebaseSearchTool, h as codebaseStatsTool, i as enqueueReindex, j as getIndexState, k as indexCircuitBreaker, l as isIndexReady, m as isIndexableFile, n as isIndexing, o as onIndexStateChange, r as resetIndexCircuitBreaker, p as runStartupIndex, s as searchCodebaseIndex, q as shutdownCodebaseIndexHost } from '../background-indexer-CJ5JiV5i.js';
 import { Context } from '@wrongstack/core';
 
 interface IndexerOptions {
@@ -17,6 +17,12 @@ interface IndexerOptions {
      * and `runIndexer` throws, releasing the mutex and resetting flags.
      */
     signal?: AbortSignal | undefined;
+    /**
+     * Per-file progress callback. Injected by the caller instead of imported
+     * from the host's module state so the indexer can run inside a worker
+     * thread (worker posts progress messages; inline host updates its state).
+     */
+    onProgress?: ((current: number, total: number) => void) | undefined;
 }
 /** Run a full or incremental index and return statistics. */
 declare function runIndexer(_ctx: Context, opts: IndexerOptions): Promise<IndexResult>;
@@ -41,12 +47,36 @@ declare class IndexStore {
     private db;
     /** Absolute path to this project's index directory. */
     private readonly indexDir;
+    /**
+     * True when the SQLite build provides FTS5 (Node's bundled SQLite does).
+     * When false, ranked search falls back to the LIKE + in-process BM25 path.
+     */
+    private ftsAvailable;
+    /**
+     * Execute a SQLite write operation with automatic retry on lock conflicts.
+     *
+     * When another wstack process is holding the write lock the statement first
+     * waits up to `busy_timeout` ms, then throws SQLITE_BUSY.  This wrapper catches
+     * that error and retries (up to MAX_LOCK_RETRIES) with exponential backoff,
+     * giving the competing writer time to finish and release the lock.
+     *
+     * @param fn  The write operation to execute. Can return a value which is
+     *            returned to the caller on success.
+     * @throws   {@link LockError} when all retries are exhausted on a lock conflict
+     *            (non-lock errors always propagate on the first attempt).
+     */
+    runWithRetry<T>(fn: () => T): T;
     constructor(projectRoot: string, opts?: {
         indexDir?: string | undefined;
     });
     private initSchema;
     insertSymbols(symbols: Symbol[], nextId: number): number;
     deleteSymbolsForFile(file: string): void;
+    /**
+     * Remove every trace of a file (refs, symbols, FTS rows, file meta). Used
+     * when a source file disappears between index runs — previously this only
+     * dropped the `files` row, leaving its symbols orphaned but still searchable.
+     */
     deleteFile(file: string): void;
     upsertFile(meta: FileMeta): void;
     getFileMeta(file: string): FileMeta | null;
@@ -57,6 +87,27 @@ declare class IndexStore {
         file?: string | undefined;
         lspKind?: number | undefined;
     }): SearchResult[];
+    /**
+     * Ranked search — the one-stop query the codebase-search tool and plug-lsp
+     * use. With FTS5 this is a single indexed `MATCH` ranked by SQLite's native
+     * `bm25()` with a built-in `snippet()`; without FTS5 it falls back to the
+     * legacy LIKE scan + in-process BM25 (identical semantics, slower).
+     *
+     * Tokens are matched as prefixes (`"tok"*`), mirroring the old
+     * `LIKE '%tok%'` recall for the common symbol-search shapes ("user" finds
+     * "users", camelCase-split text makes "complex" find "complexOperation").
+     */
+    searchRanked(query: string, filter: {
+        kind?: SymbolKind | undefined;
+        lang?: SymbolLang | undefined;
+        file?: string | undefined;
+        lspKind?: number | undefined;
+    } | undefined, limit: number): {
+        results: SearchResult[];
+        total: number;
+    };
+    /** Legacy ranked path: LIKE candidates + in-process BM25 + JS snippets. */
+    private searchRankedFallback;
     getAllIndexable(): Array<{
         id: number;
         text: string;