dsh-locator 0.7.1 → 0.7.5

package/src/content-search-worker.ts

@@ -0,0 +1,52 @@
+/**
+ * Search worker: the FTS5 query runs here so a slow content query can never
+ * stall the DSH host's event loop. A read-only connection makes the build's
+ * writes in the main thread safe to observe concurrently (WAL).
+ * @module dsh-locator/content-search-worker
+ */
+
+import { parentPort, workerData } from 'node:worker_threads'
+import { DatabaseSync } from 'node:sqlite'
+import { searchContent } from './content-search.ts'
+import type { ContentHit } from './content.ts'
+
+interface Request {
+  id: number
+  open?: string
+  close?: boolean
+  query?: string
+  limit?: number
+}
+
+let db: DatabaseSync | null = null
+
+function open(path: string): void {
+  try { db?.close() } catch { /* ignore */ }
+  db = null
+  try { db = new DatabaseSync(path, { readOnly: true }) } catch { db = null }
+}
+
+const initial = (workerData as { dbPath?: string } | undefined)?.dbPath
+if (initial !== undefined) open(initial)
+
+parentPort?.on('message', (request: Request) => {
+  if (request.open !== undefined) {
+    open(request.open)
+    parentPort?.postMessage({ id: request.id, ok: true })
+    return
+  }
+  if (request.close === true) {
+    try { db?.close() } catch { /* ignore */ }
+    db = null
+    parentPort?.postMessage({ id: request.id, ok: true })
+    return
+  }
+  let hits: ContentHit[] = []
+  let error = ''
+  if (db !== null) {
+    try { hits = searchContent(db, request.query ?? '', request.limit ?? 30) } catch (cause) {
+      error = cause instanceof Error ? cause.message : String(cause)
+    }
+  }
+  parentPort?.postMessage({ id: request.id, hits, error })
+})

package/src/content-search.ts

@@ -0,0 +1,45 @@
+/**
+ * Content FTS5 query shared by the host thread and the search worker.
+ * @module dsh-locator/content-search
+ */
+
+import type { DatabaseSync } from 'node:sqlite'
+import type { ContentHit } from './content.ts'
+
+/**
+ * Run one content query against an open SQLite handle.
+ * @param db - open database (read-only in the worker).
+ * @param query - user query; shorter than three characters falls back to LIKE.
+ * @param limit - maximum hits.
+ * @returns hits, ordered by relevance.
+ */
+export function searchContent(db: DatabaseSync, query: string, limit: number): ContentHit[] {
+  const text = query.trim()
+  if (text === '') return []
+  const capped = Math.max(1, Math.min(100, limit))
+  let rows: Array<Record<string, unknown>>
+  if ([...text].length < 3) {
+    // A one- or two-character query cannot use the trigram index, so bound the
+    // payload as well as the row count: never ship a whole megabyte body.
+    rows = db.prepare(`SELECT kind, path, title, session_id, message_id,
+      substr(body, 1, 400) AS snippet, 0 AS score
+      FROM docs WHERE body LIKE '%' || ? || '%' LIMIT ?`).all(text, capped) as Array<Record<string, unknown>>
+  } else {
+    const match = text.split(/\s+/).filter(Boolean).map(term => '"' + term.replace(/"/g, '') + '"').join(' AND ')
+    // Keep MATCH in this statement: FTS5 snippet() and bm25() are only defined
+    // inside a matching query (a rowid subquery silently degrades both). The
+    // query runs in the search worker, so its cost stays off the host thread.
+    rows = db.prepare(`SELECT kind, path, title, session_id, message_id,
+      snippet(docs, 0, char(1), char(2), '…', 16) AS snippet, bm25(docs) AS score
+      FROM docs WHERE docs MATCH ? ORDER BY score LIMIT ?`).all(match, capped) as Array<Record<string, unknown>>
+  }
+  return rows.map(row => ({
+    kind: row.kind === 'session' ? 'session' : 'file',
+    path: String(row.path ?? ''),
+    title: String(row.title ?? ''),
+    snippet: String(row.snippet ?? row.body ?? '').replace(/[\u0001\u0002]/g, ''),
+    ...(row.session_id ? { sessionId: String(row.session_id) } : {}),
+    ...(row.message_id ? { messageId: String(row.message_id) } : {}),
+    score: Number(row.score ?? 0),
+  }))
+}