@bojackduy/opencode-telescope 0.1.24 → 0.1.26

package/search.ts

@@ -1,1510 +1,47 @@
-import { Database } from "bun:sqlite"
-import { createHash } from "node:crypto"
-import { existsSync, readdirSync, statSync } from "node:fs"
-import { homedir } from "node:os"
-import path from "node:path"
-import { debug } from "./ui/debug.ts"
-import { LlamaEmbeddingClient } from "./search/embedding.ts"
-
-export type SearchResult = {
-  id: string
-  messageID: string
-  sessionID: string
-  sessionTitle: string
-  directory: string
-  role: "user" | "assistant"
-  partType: "text" | "reasoning" | "tool"
-  tool?: string
-  timeCreated: number
-  snippet: string
-  matchStart: number
-  matchEnd: number
-  before: string
-  match: string
-  after: string
-  excerpt: string
-  previewBefore: string
-  previewMatch: string
-  previewAfter: string
-  previewMode: "markdown" | "text"
-  previewHighlight: boolean
-  text: string
-}
-
-export type SearchRole = "user" | "assistant"
-
-export type ConversationPreviewPart = {
-  id: string
-  messageID: string
-  sessionID: string
-  role: "user" | "assistant"
-  type: "text" | "reasoning" | "tool"
-  timeCreated: number
-  text: string
-  tool?: string
-  state?: ToolState
-  target: boolean
-}
-
-export type ConversationPreviewPage = {
-  parts: ConversationPreviewPart[]
-  hasMoreBefore: boolean
-  hasMoreAfter: boolean
-}
-
-export type ConversationPreviewCursor = {
-  id: string
-  timeCreated: number
-}
-
-export type ToolState = {
-  status: "pending" | "running" | "completed" | "error"
-  input?: unknown
-  metadata?: unknown
-  output?: string
-  error?: string
-}
-
-export type SemanticConfig = {
-  embedBaseUrl: string
-  embedModel?: string
-  disableVector: boolean
-  sqliteLibPath?: string
-  sqliteVecExtension?: string
-  hybridAlpha: number
-  documentPrefix: string
-  queryPrefix: string
-}
-
-export type VectorState = "enabled" | "disabled" | "unavailable" | "stale"
-
-export const DEFAULT_EMBED_BASE_URL = "http://127.0.0.1:8081"
-export const DEFAULT_DOCUMENT_PREFIX = "search_document: "
-export const DEFAULT_QUERY_PREFIX = "search_query: "
-export const DEFAULT_HYBRID_ALPHA = 0.45
-
-export function parseSemanticConfig(env: Record<string, string | undefined> = process.env): SemanticConfig {
-  return {
-    embedBaseUrl: env.OPENCODE_TELESCOPE_EMBED_BASE_URL ?? DEFAULT_EMBED_BASE_URL,
-    embedModel: env.OPENCODE_TELESCOPE_EMBED_MODEL || undefined,
-    disableVector: env.OPENCODE_TELESCOPE_DISABLE_VECTOR === "1" || env.OPENCODE_TELESCOPE_DISABLE_VECTOR === "true",
-    sqliteLibPath: env.OPENCODE_TELESCOPE_SQLITE_LIB || undefined,
-    sqliteVecExtension: env.OPENCODE_TELESCOPE_SQLITE_VEC_EXT || undefined,
-    hybridAlpha: parseAlpha(env.OPENCODE_TELESCOPE_HYBRID_ALPHA),
-    documentPrefix: DEFAULT_DOCUMENT_PREFIX,
-    queryPrefix: DEFAULT_QUERY_PREFIX,
-  }
-}
-
-function parseAlpha(value: string | undefined) {
-  if (!value) return DEFAULT_HYBRID_ALPHA
-  const parsed = Number(value)
-  if (!Number.isFinite(parsed)) return DEFAULT_HYBRID_ALPHA
-  if (parsed < 0) return 0
-  if (parsed > 1) return 1
-  return parsed
-}
-
-type Row = {
-  id: string
-  message_id: string
-  session_id: string
-  session_title: string | null
-  directory: string
-  role: SearchRole
-  part_type?: SearchResult["partType"]
-  tool?: string | null
-  time_created: number
-  text: string
-}
-
-type IndexSourceRow = Omit<Row, "text"> & {
-  data: string
-}
-
-export type DocumentRow = {
-  doc_id: string
-  part_id: string
-  message_id: string
-  session_id: string
-  session_title: string
-  directory: string
-  role: string
-  part_type: string
-  tool: string | null
-  time_created: number
-  chunk_index: number
-  text: string
-  source_hash: string
-  extractor_version: string
-}
-
-type ConversationRow = {
-  id: string
-  message_id: string
-  session_id: string
-  role: SearchRole
-  type: "text" | "reasoning" | "tool"
-  time_created: number
-  data: string
-}
-
-let cachedDbPath: string | undefined
-let _db: Database | undefined
-let _dbPath: string | undefined
-let _indexDb: Database | undefined
-let _indexDbPath: string | undefined
-const backgroundIndexRebuilds = new Set<string>()
-
-function getDb(dbPath?: string): Database {
-  const resolved = dbPath ?? resolveDatabasePath()
-  if (!_db || resolved !== _dbPath) {
-    _db?.close()
-    _db = new Database(resolved, { readonly: true })
-    _dbPath = resolved
-    tableCache.clear()
-  }
-  return _db
-}
-
-export function resolveDatabasePath() {
-  if (cachedDbPath) return cachedDbPath
-  if (process.env.OPENCODE_DB) {
-    if (process.env.OPENCODE_DB === ":memory:" || path.isAbsolute(process.env.OPENCODE_DB)) return cachedDbPath = process.env.OPENCODE_DB
-    return cachedDbPath = path.join(candidateDataDirs()[0] ?? defaultDataDir(), process.env.OPENCODE_DB)
-  }
-  if (process.env.OPENCODE_DISABLE_CHANNEL_DB === "1" || process.env.OPENCODE_DISABLE_CHANNEL_DB === "true") {
-    return cachedDbPath = requireExistingDatabase(["opencode.db"])
-  }
-  const stable = candidateDatabasePaths(["opencode.db"]).find(existsSync)
-  if (stable) return cachedDbPath = stable
-  if (process.env.OPENCODE_CHANNEL) {
-    const channel = process.env.OPENCODE_CHANNEL.replace(/[^a-zA-Z0-9._-]/g, "-")
-    const candidate = candidateDatabasePaths([`opencode-${channel}.db`]).find(existsSync)
-    if (candidate) return cachedDbPath = candidate
-  }
-  const fallback = candidateDatabasePaths(["opencode.db"])[0] ?? path.join(defaultDataDir(), "opencode.db")
-  try {
-    const discovered = candidateDataDirs()
-      .flatMap((dir) =>
-        readdirSync(dir, { withFileTypes: true })
-          .filter((entry) => entry.isFile() && /^opencode-.+\.db$/.test(entry.name))
-          .map((entry) => path.join(dir, entry.name)),
-      )
-      .at(0)
-    return cachedDbPath = discovered ?? fallback
-  } catch {
-    return cachedDbPath = fallback
-  }
-}
-
-export function searchSessionMessages(query: string, options?: { limit?: number; offset?: number; dbPath?: string; directory?: string; role?: SearchRole }) {
-  const term = query.trim()
-  if (!term) return []
-  if (options?.dbPath === ":memory:") return []
-  const dbPath = options?.dbPath ?? resolveDatabasePath()
-  const db = getDb(dbPath)
-  return searchRows(db, dbPath, term, options?.limit ?? 80, options?.directory, options?.offset, options?.role)
-}
-
-export function recentSessionMessages(options?: { limit?: number; offset?: number; dbPath?: string; directory?: string; role?: SearchRole }) {
-  const dbPath = options?.dbPath ?? resolveDatabasePath()
-  const db = getDb(dbPath)
-  const limit = options?.limit ?? 40
-  const indexed = dbPath === ":memory:" ? undefined : indexedRecentRows(db, dbPath, limit, options?.directory, options?.offset, options?.role)
-  if (indexed) return indexed.flatMap((row) => rowToSearchResult(row, "") ?? [])
-  debug.log("query:recent:source-fallback", { limit, offset: options?.offset ?? 0, directory: options?.directory, role: options?.role })
-  return visibleTextRows(db, limit, undefined, options?.directory, options?.offset, options?.role).flatMap(
-    (row) => rowToSearchResult(row, "") ?? [],
-  )
-}
-
-export function loadConversationAround(result: SearchResult, options?: { before?: number; after?: number; dbPath?: string }): ConversationPreviewPage {
-  debug.time("preview:query:total")
-  const db = getDb(options?.dbPath)
-  const before = options?.before ?? 3
-  const after = options?.after ?? 6
-
-  debug.time("preview:query:hit")
-  const hit = db.query<{ time_created: number }, [string]>(
-    "SELECT time_created FROM part WHERE id = ?",
-  ).get(result.id)
-  debug.timeEnd("preview:query:hit")
-  if (!hit) {
-    debug.log("preview:window", {
-      item: result.id,
-      session: result.sessionID,
-      before,
-      after,
-      hit: false,
-    })
-    debug.timeEnd("preview:query:total")
-    return { parts: [], hasMoreBefore: false, hasMoreAfter: false }
-  }
-
-  const fetchBefore = Math.max(before * 4, before + 1, 30)
-  const fetchAfter = Math.max((after + 1) * 4, after + 2, 50)
-
-  debug.time("preview:query:before")
-  const beforeRows = db.query<ConversationRow, [string, number, number, string, number]>(`
-    SELECT p.id, p.message_id, p.session_id,
-           json_extract(m.data, '$.role') AS role,
-           json_extract(p.data, '$.type') AS type,
-           p.time_created, p.data
-    FROM part p
-    JOIN message m ON m.id = p.message_id
-    WHERE p.session_id = ?
-      AND (p.time_created < ? OR (p.time_created = ? AND p.id < ?))
-    ORDER BY p.time_created DESC, p.id DESC
-    LIMIT ?
-  `).all(result.sessionID, hit.time_created, hit.time_created, result.id, fetchBefore)
-  debug.timeEnd("preview:query:before")
-
-  debug.time("preview:query:after")
-  const afterRows = db.query<ConversationRow, [string, number, number, string, number]>(`
-    SELECT p.id, p.message_id, p.session_id,
-           json_extract(m.data, '$.role') AS role,
-           json_extract(p.data, '$.type') AS type,
-           p.time_created, p.data
-    FROM part p
-    JOIN message m ON m.id = p.message_id
-    WHERE p.session_id = ?
-      AND (p.time_created > ? OR (p.time_created = ? AND p.id >= ?))
-    ORDER BY p.time_created ASC, p.id ASC
-    LIMIT ?
-  `).all(result.sessionID, hit.time_created, hit.time_created, result.id, fetchAfter)
-  debug.timeEnd("preview:query:after")
-
-  debug.time("preview:query:parse")
-  const validBefore = beforeRows.filter(isPreviewRow)
-  const validAfter = afterRows.filter(isPreviewRow)
-  const parts = [
-    ...validBefore.slice(0, before).reverse(),
-    ...validAfter.slice(0, after + 1),
-  ].flatMap((row) => parseConversationPart(row, row.id === result.id) ?? [])
-  const page = {
-    parts,
-    hasMoreBefore: validBefore.length > before,
-    hasMoreAfter: validAfter.length > after + 1,
-  }
-  debug.log("preview:window", {
-    item: result.id,
-    session: result.sessionID,
-    mode: "around",
-    before,
-    after,
-    fetchBefore,
-    fetchAfter,
-    beforeRows: beforeRows.length,
-    validBefore: validBefore.length,
-    invalidBefore: previewRowBreakdown(beforeRows, validBefore),
-    afterRows: afterRows.length,
-    validAfter: validAfter.length,
-    invalidAfter: previewRowBreakdown(afterRows, validAfter),
-    parts: parts.length,
-    hasMoreBefore: page.hasMoreBefore,
-    hasMoreAfter: page.hasMoreAfter,
-    first: parts[0]?.id,
-    last: parts.at(-1)?.id,
-  })
-  debug.timeEnd("preview:query:parse")
-  debug.timeEnd("preview:query:total")
-  return page
-}
-
-export function loadConversationBefore(result: SearchResult, cursor: ConversationPreviewCursor, options?: { limit?: number; dbPath?: string }) {
-  debug.time("preview:query:before-page")
-  const db = getDb(options?.dbPath)
-  const limit = options?.limit ?? 20
-  const fetchLimit = Math.max(limit * 4, limit + 1, 30)
-  const rows = db.query<ConversationRow, [string, number, number, string, number]>(`
-    SELECT p.id, p.message_id, p.session_id,
-           json_extract(m.data, '$.role') AS role,
-           json_extract(p.data, '$.type') AS type,
-           p.time_created, p.data
-    FROM part p
-    JOIN message m ON m.id = p.message_id
-    WHERE p.session_id = ?
-      AND (p.time_created < ? OR (p.time_created = ? AND p.id < ?))
-    ORDER BY p.time_created DESC, p.id DESC
-    LIMIT ?
-  `).all(result.sessionID, cursor.timeCreated, cursor.timeCreated, cursor.id, fetchLimit)
-  const valid = rows.filter(isPreviewRow)
-  const parts = valid.slice(0, limit).reverse().flatMap((row) => parseConversationPart(row, false) ?? [])
-  const parsedIds = new Set(parts.map((part) => part.id))
-  const page = { parts, hasMoreBefore: valid.length > limit }
-  debug.log("preview:window", {
-    item: result.id,
-    session: result.sessionID,
-    mode: "before",
-    cursor,
-    limit,
-    rows: rows.length,
-    valid: valid.length,
-    invalid: previewRowBreakdown(rows, valid),
-    parts: parts.length,
-    unparsedValid: valid.slice(0, limit).filter((row) => !parsedIds.has(row.id)).map((row) => ({ id: row.id, type: row.type, role: row.role })),
-    hasMoreBefore: page.hasMoreBefore,
-    first: parts[0]?.id,
-    last: parts.at(-1)?.id,
-  })
-  debug.timeEnd("preview:query:before-page")
-  return page
-}
-
-export function loadConversationAfter(result: SearchResult, cursor: ConversationPreviewCursor, options?: { limit?: number; dbPath?: string }) {
-  debug.time("preview:query:after-page")
-  const db = getDb(options?.dbPath)
-  const limit = options?.limit ?? 20
-  const fetchLimit = Math.max(limit * 4, limit + 1, 30)
-  const rows = db.query<ConversationRow, [string, number, number, string, number]>(`
-    SELECT p.id, p.message_id, p.session_id,
-           json_extract(m.data, '$.role') AS role,
-           json_extract(p.data, '$.type') AS type,
-           p.time_created, p.data
-    FROM part p
-    JOIN message m ON m.id = p.message_id
-    WHERE p.session_id = ?
-      AND (p.time_created > ? OR (p.time_created = ? AND p.id > ?))
-    ORDER BY p.time_created ASC, p.id ASC
-    LIMIT ?
-  `).all(result.sessionID, cursor.timeCreated, cursor.timeCreated, cursor.id, fetchLimit)
-  const valid = rows.filter(isPreviewRow)
-  const parts = valid.slice(0, limit).flatMap((row) => parseConversationPart(row, false) ?? [])
-  const parsedIds = new Set(parts.map((part) => part.id))
-  const page = { parts, hasMoreAfter: valid.length > limit }
-  debug.log("preview:window", {
-    item: result.id,
-    session: result.sessionID,
-    mode: "after",
-    cursor,
-    limit,
-    rows: rows.length,
-    valid: valid.length,
-    invalid: previewRowBreakdown(rows, valid),
-    parts: parts.length,
-    unparsedValid: valid.slice(0, limit).filter((row) => !parsedIds.has(row.id)).map((row) => ({ id: row.id, type: row.type, role: row.role })),
-    hasMoreAfter: page.hasMoreAfter,
-    first: parts[0]?.id,
-    last: parts.at(-1)?.id,
-  })
-  debug.timeEnd("preview:query:after-page")
-  return page
-}
-
-export function rowToSearchResult(row: Row, query: string): SearchResult | undefined {
-  const text = row.text.trim()
-  const match = findMatch(text, query)
-  if (!match) return
-  const preview = focusedPreview(text, match.start, match.end)
-  return {
-    id: row.id,
-    messageID: row.message_id,
-    sessionID: row.session_id,
-    sessionTitle: row.session_title || "Untitled session",
-    directory: row.directory,
-    role: row.role,
-    partType: row.part_type ?? "text",
-    tool: row.tool ?? undefined,
-    timeCreated: row.time_created,
-    snippet: makeSnippet(text, query),
-    matchStart: match.start,
-    matchEnd: match.end,
-    before: match.before,
-    match: match.match,
-    after: match.after,
-    excerpt: match.excerpt,
-    previewBefore: preview.before,
-    previewMatch: preview.match,
-    previewAfter: preview.after,
-    previewMode: preview.mode,
-    previewHighlight: preview.highlight,
-    text,
-  }
-}
-
-export function extractSearchText(data: string) {
-  try {
-    return extractFromValue(JSON.parse(data)).replace(/\s+/g, " ").trim()
-  } catch {
-    return data.replace(/\s+/g, " ").trim()
-  }
-}
-
-export function makeSnippet(text: string, query: string, radius = 72) {
-  const haystack = text.replace(/\s+/g, " ").trim()
-  const tokens = query.trim().split(/\s+/)
-  const lower = haystack.toLowerCase()
-  let searchPos = 0
-  let firstIndex = -1
-  let lastEnd = 0
-  for (const token of tokens) {
-    const index = lower.indexOf(token.toLowerCase(), searchPos)
-    if (index === -1) return truncate(haystack, radius * 2)
-    if (firstIndex === -1) firstIndex = index
-    searchPos = index + token.length
-    lastEnd = searchPos
-  }
-  const start = Math.max(0, firstIndex - radius)
-  const end = Math.min(haystack.length, lastEnd + radius)
-  return `${start > 0 ? "..." : ""}${haystack.slice(start, end)}${end < haystack.length ? "..." : ""}`
-}
-
-function findMatch(text: string, query: string, radius = 96) {
-  const needle = query.trim()
-  if (!needle) {
-    const collapsed = text.replace(/\s+/g, " ").trim()
-    const end = Math.min(collapsed.length, radius * 2)
-    return {
-      start: 0,
-      end: 0,
-      before: "",
-      match: "",
-      after: collapsed.slice(0, end),
-      excerpt: collapsed.slice(0, end),
-    }
-  }
-  const tokens = needle.split(/\s+/)
-  const lowerText = text.toLowerCase()
-  let searchPos = 0
-  let firstStart = -1
-  let lastEnd = -1
-  for (const token of tokens) {
-    const pos = lowerText.indexOf(token.toLowerCase(), searchPos)
-    if (pos === -1) return
-    if (firstStart === -1) firstStart = pos
-    searchPos = pos + token.length
-    lastEnd = searchPos
-  }
-  const start = firstStart
-  const end = lastEnd
-  const lineStart = text.lastIndexOf("\n", start - 1) + 1
-  const nextLine = text.indexOf("\n", end)
-  const lineEnd = nextLine === -1 ? text.length : nextLine
-  const line = text.slice(lineStart, lineEnd)
-  const matchLen = end - start
-  const lineMatchStart = Math.max(0, start - lineStart)
-  const lineMatchEnd = lineMatchStart + matchLen
-  const excerptStart = Math.max(0, lineMatchStart - radius)
-  const excerptEnd = Math.min(line.length, lineMatchEnd + radius)
-  const before = normalizeSnippetSegment(line.slice(excerptStart, lineMatchStart))
-  const after = normalizeSnippetSegment(line.slice(lineMatchEnd, excerptEnd))
-  return {
-    start,
-    end,
-    before: `${excerptStart > 0 ? "..." : ""}${before}`,
-    match: text.slice(start, end),
-    after: `${after}${excerptEnd < line.length ? "..." : ""}`,
-    excerpt: `${excerptStart > 0 ? "..." : ""}${normalizeSnippetSegment(line.slice(excerptStart, excerptEnd))}${excerptEnd < line.length ? "..." : ""}`,
-  }
-}
-
-function normalizeSnippetSegment(value: string) {
-  return value.replace(/\s+/g, " ")
-}
-
-function focusedPreview(text: string, matchStart: number, matchEnd: number) {
-  if (matchStart === matchEnd) {
-    const preview = text.slice(0, Math.min(text.length, 1400))
-    return { before: preview, match: "", after: "", mode: "markdown" as const, highlight: false }
-  }
-
-  const lineStart = text.lastIndexOf("\n", matchStart - 1) + 1
-  const nextLine = text.indexOf("\n", matchEnd)
-  const lineEnd = nextLine === -1 ? text.length : nextLine
-  const line = text.slice(lineStart, lineEnd)
-
-  if (line.length > 260) {
-    const beforeStart = Math.max(0, matchStart - 180)
-    const afterEnd = Math.min(text.length, matchEnd + 220)
-    return {
-      before: `${beforeStart > 0 ? "..." : ""}${text.slice(beforeStart, matchStart)}`,
-      match: text.slice(matchStart, matchEnd),
-      after: `${text.slice(matchEnd, afterEnd)}${afterEnd < text.length ? "..." : ""}`,
-      mode: "text" as const,
-      highlight: true,
-    }
-  }
-
-  const window = lineWindow(text, matchStart, matchEnd, 40, 80)
-  const windowText = text.slice(window.start, window.end)
-  const relativeStart = matchStart - window.start
-  const relativeEnd = matchEnd - window.start
-
-  const insideCodeFence = isInsideCodeFence(text, matchStart)
-  return {
-    before: `${window.start > 0 ? "...\n" : ""}${windowText.slice(0, relativeStart)}`,
-    match: windowText.slice(relativeStart, relativeEnd),
-    after: `${windowText.slice(relativeEnd)}${window.end < text.length ? "\n..." : ""}`,
-    mode: "markdown" as const,
-    highlight: !insideCodeFence,
-  }
-}
-
-function lineWindow(text: string, matchStart: number, matchEnd: number, before: number, after: number) {
-  const starts = [0]
-  for (let index = text.indexOf("\n"); index !== -1; index = text.indexOf("\n", index + 1)) {
-    starts.push(index + 1)
-  }
-  const matchLine = findLastStartIndex(starts, matchStart)
-  const startLine = Math.max(0, matchLine - before)
-  const endLine = Math.min(starts.length - 1, matchLine + after)
-  const start = starts[startLine] ?? 0
-  const end = starts[endLine + 1] ? starts[endLine + 1] - 1 : text.length
-  return { start, end: Math.max(end, matchEnd) }
-}
-
-function findLastStartIndex(starts: number[], offset: number) {
-  for (let index = starts.length - 1; index >= 0; index--) {
-    if (starts[index]! <= offset) return index
-  }
-  return 0
-}
-
-function isInsideCodeFence(text: string, offset: number) {
-  const before = text.slice(0, offset)
-  const fences = before.match(/^```/gm)
-  return Boolean(fences && fences.length % 2 === 1)
-}
-
-function parseConversationPart(row: ConversationRow, target: boolean): ConversationPreviewPart | undefined {
-  const data = parsePartData(row.data)
-  if (!data) return
-  if (row.type === "tool") {
-    return {
-      id: row.id,
-      messageID: row.message_id,
-      sessionID: row.session_id,
-      role: row.role,
-      type: row.type,
-      timeCreated: row.time_created,
-      text: target ? extractToolIndexText(data).trim() : "",
-      tool: typeof data.tool === "string" ? data.tool : "tool",
-      state: parseToolState(data.state),
-      target,
-    }
-  }
-  const text = typeof data.text === "string" ? data.text.trim() : ""
-  if (!text) return
-  return {
-    id: row.id,
-    messageID: row.message_id,
-    sessionID: row.session_id,
-    role: row.role,
-    type: row.type,
-    timeCreated: row.time_created,
-    text,
-    target,
-  }
-}
-
-function isPreviewRow(row: ConversationRow) {
-  return (row.role === "user" || row.role === "assistant") &&
-    (row.type === "text" || row.type === "reasoning" || row.type === "tool")
-}
-
-function previewRowBreakdown(rows: ConversationRow[], validRows: ConversationRow[]) {
-  const valid = new Set(validRows.map((row) => row.id))
-  const invalidRows = rows.filter((row) => !valid.has(row.id))
-  if (invalidRows.length === 0) return undefined
-  const byRole = countBy(invalidRows, (row) => String(row.role ?? "unknown"))
-  const byType = countBy(invalidRows, (row) => String(row.type ?? "unknown"))
-  return { count: invalidRows.length, byRole, byType }
-}
-
-function countBy<T>(items: T[], key: (item: T) => string) {
-  const counts: Record<string, number> = {}
-  for (const item of items) counts[key(item)] = (counts[key(item)] ?? 0) + 1
-  return counts
-}
-
-function parsePartData(data: string) {
-  try {
-    const value = JSON.parse(data) as unknown
-    if (!value || typeof value !== "object" || Array.isArray(value)) return
-    return value as Record<string, unknown>
-  } catch {
-    return
-  }
-}
-
-function parseToolState(value: unknown): ToolState | undefined {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return
-  const state = value as Record<string, unknown>
-  if (!["pending", "running", "completed", "error"].includes(String(state.status))) return
-  return {
-    status: state.status as ToolState["status"],
-    input: state.input,
-    metadata: state.metadata,
-    output: typeof state.output === "string" ? state.output : undefined,
-    error: typeof state.error === "string" ? state.error : undefined,
-  }
-}
-
-function searchRows(db: Database, dbPath: string, query: string, limit: number, directory?: string, offset?: number, role?: SearchRole) {
-  if (!tableExists(db, "part") || !tableExists(db, "message")) return []
-  debug.time("query:sql")
-  const rows = indexedTextRows(db, dbPath, limit, query, directory, offset, role) ?? visibleTextRows(db, limit, query, directory, offset, role)
-  debug.timeEnd("query:sql")
-  debug.time("query:map")
-  const results = rows.flatMap((row) => rowToSearchResult(row, query) ?? [])
-  debug.timeEnd("query:map")
-  return results
-}
-
-function indexedTextRows(db: Database, dbPath: string, limit: number, query: string, directory?: string, offset?: number, role?: SearchRole) {
-  const match = ftsQuery(query)
-  if (!match) return []
-  try {
-    const index = ensureSearchIndex(db, dbPath)
-    if (!index) return []
-    const conditions = ["document_fts MATCH ?"]
-    const params: (string | number)[] = [match]
-    if (role) {
-      conditions.push("role = ?")
-      params.push(role)
-    }
-    if (directory) {
-      conditions.push("directory = ?")
-      params.push(directory)
-    }
-    params.push(limit)
-    if (offset) params.push(offset)
-    const offsetClause = offset ? "OFFSET ?" : ""
-    debug.time("query:fts:exec")
-    const rows = index.query<Row, (string | number)[]>(`
-      SELECT id, message_id, session_id, session_title, directory, role, part_type, tool,
-             CAST(time_created AS INTEGER) AS time_created, text
-      FROM document_fts
-      WHERE ${conditions.join(" AND ")}
-      ORDER BY bm25(document_fts), CAST(time_created AS INTEGER) DESC
-      LIMIT ? ${offsetClause}
-    `).all(...params as any[])
-    debug.timeEnd("query:fts:exec")
-    return rows
-  } catch (err) {
-    debug.log("fts:fallback", err instanceof Error ? err.message : String(err))
-    return
-  }
-}
-
-function indexedRecentRows(db: Database, dbPath: string, limit: number, directory?: string, offset?: number, role?: SearchRole) {
-  try {
-    const index = ensureSearchIndex(db, dbPath, { rebuild: false, useStale: true })
-    if (!index) {
-      debug.log("query:recent:index:missing", { dbPath })
-      return
-    }
-
-    const rowCount = index.query<{ count: number }, []>("SELECT COUNT(*) as count FROM document_index").get()?.count ?? 0
-    if (rowCount === 0) {
-      debug.log("query:recent:index:empty", { dbPath })
-      return
-    }
-
-    const state = sourceState(db, dbPath)
-    const currentDataVersion = getMeta(index, "source_data_version")
-    const currentMtimeMs = getMeta(index, "source_mtime_ms")
-    const currentPath = getMeta(index, "source_path")
-    const currentIndexVersion = getMeta(index, "index_version")
-    if (currentPath !== dbPath || currentDataVersion !== String(state.dataVersion) || currentMtimeMs !== String(state.mtimeMs) || currentIndexVersion !== SEARCH_INDEX_VERSION) {
-      debug.log("query:recent:index:stale", {
-        dbPath,
-        expectedDataVersion: state.dataVersion,
-        actualDataVersion: currentDataVersion,
-      })
-    }
-
-    const conditions: string[] = ["part_type = 'text'"]
-    const params: (string | number)[] = []
-    if (role) {
-      conditions.push("role = ?")
-      params.push(role)
-    }
-    if (directory) {
-      conditions.push("directory = ?")
-      params.push(directory)
-    }
-    params.push(limit)
-    if (offset) params.push(offset)
-
-    const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""
-    const offsetClause = offset ? "OFFSET ?" : ""
-    debug.time("query:recent:index:exec")
-    const rows = index.query<Row, (string | number)[]>(`
-      SELECT id, message_id, session_id, session_title, directory, role, part_type, tool,
-             CAST(time_created AS INTEGER) AS time_created, text
-      FROM document_index
-      ${where}
-      ORDER BY CAST(time_created AS INTEGER) DESC
-      LIMIT ? ${offsetClause}
-    `).all(...params as any[])
-    debug.timeEnd("query:recent:index:exec")
-    return rows
-  } catch (err) {
-    debug.log("recent:index:fallback", err instanceof Error ? err.message : String(err))
-    return
-  }
-}
-
-function visibleTextRows(db: Database, limit: number, query?: string, directory?: string, offset?: number, role?: SearchRole) {
-  const offsetClause = offset ? "OFFSET ?" : ""
-  const conditions: string[] = [
-    "json_extract(p.data, '$.type') = 'text'",
-    role ? "json_extract(m.data, '$.role') = ?" : "json_extract(m.data, '$.role') IN ('user', 'assistant')",
-  ]
-  const params: (string | number)[] = []
-
-  if (role) params.push(role)
-
-  if (directory) {
-    conditions.push("s.directory = ?")
-    params.push(directory)
-  }
-
-  const tokens = query ? query.trim().split(/\s+/).filter(Boolean) : []
-  for (const token of tokens) {
-    conditions.push("json_extract(p.data, '$.text') LIKE ?")
-    params.push(`%${token}%`)
-  }
-
-  params.push(limit)
-  if (offset) params.push(offset)
-
-  const sql = `
-    SELECT p.id, p.message_id, p.session_id, s.title AS session_title, s.directory,
-           json_extract(m.data, '$.role') AS role,
-           p.time_created,
-           json_extract(p.data, '$.text') AS text
-    FROM part p
-    JOIN message m ON m.id = p.message_id
-    JOIN session s ON s.id = p.session_id
-    WHERE ${conditions.join(" AND ")}
-    ORDER BY p.time_created DESC
-    LIMIT ? ${offsetClause}
-  `
-  debug.time("query:sql:exec")
-  const rows = db.query<Row, (string | number)[]>(sql).all(...params as any[])
-  debug.timeEnd("query:sql:exec")
-  return rows
-}
-
-function ensureSearchIndex(source: Database, sourcePath: string, options?: { rebuild?: boolean; useStale?: boolean }) {
-  const indexPath = searchIndexPath(sourcePath)
-  if (!_indexDb || _indexDbPath !== indexPath) {
-    _indexDb?.close()
-    configureCustomSQLite()
-    _indexDb = new Database(indexPath)
-    _indexDbPath = indexPath
-    migrateSearchIndex(_indexDb)
-  }
-
-  const state = sourceState(source, sourcePath)
-  const currentDataVersion = getMeta(_indexDb, "source_data_version")
-  const currentMtimeMs = getMeta(_indexDb, "source_mtime_ms")
-  const currentPath = getMeta(_indexDb, "source_path")
-  const currentIndexVersion = getMeta(_indexDb, "index_version")
-  if (currentPath !== sourcePath || currentDataVersion !== String(state.dataVersion) || currentMtimeMs !== String(state.mtimeMs) || currentIndexVersion !== SEARCH_INDEX_VERSION) {
-    if (options?.rebuild === false) {
-      if (options?.useStale) return _indexDb
-      return
-    }
-    rebuildSearchIndex(source, _indexDb, sourcePath, state)
-  }
-  return _indexDb
-}
-
-function scheduleBackgroundIndexRebuild(dbPath: string) {
-  if (backgroundIndexRebuilds.has(dbPath)) return
-  backgroundIndexRebuilds.add(dbPath)
-  debug.log("fts:rebuild:background-scheduled", { dbPath })
-  const timer = setTimeout(() => {
-    debug.time("fts:rebuild:background")
-    try {
-      const db = getDb(dbPath)
-      ensureSearchIndex(db, dbPath)
-    } catch (err) {
-      debug.log("fts:rebuild:background:error", err instanceof Error ? err.message : String(err))
-    } finally {
-      backgroundIndexRebuilds.delete(dbPath)
-      debug.timeEnd("fts:rebuild:background")
-    }
-  }, 250)
-  ;(timer as { unref?: () => void }).unref?.()
-}
-
-const SEARCH_INDEX_VERSION = "7"
-const DOCUMENT_EXTRACTOR_VERSION = "1"
-
-function searchIndexPath(sourcePath: string) {
-  const parsed = path.parse(sourcePath)
-  return path.join(parsed.dir, `${parsed.name}-telescope-search.db`)
-}
-
-function migrateSearchIndex(db: Database) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS index_meta(
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS document(
-      rowid INTEGER PRIMARY KEY,
-      doc_id TEXT UNIQUE NOT NULL,
-      part_id TEXT NOT NULL,
-      message_id TEXT NOT NULL,
-      session_id TEXT NOT NULL,
-      session_title TEXT NOT NULL,
-      directory TEXT NOT NULL,
-      role TEXT NOT NULL,
-      part_type TEXT NOT NULL,
-      tool TEXT,
-      time_created INTEGER NOT NULL,
-      chunk_index INTEGER NOT NULL,
-      text TEXT NOT NULL,
-      source_hash TEXT NOT NULL,
-      extractor_version TEXT NOT NULL,
-      indexed_at INTEGER NOT NULL
-    );
-    CREATE VIRTUAL TABLE IF NOT EXISTS document_fts USING fts5(
-      id UNINDEXED,
-      message_id UNINDEXED,
-      session_id UNINDEXED,
-      session_title,
-      directory UNINDEXED,
-      role UNINDEXED,
-      part_type UNINDEXED,
-      tool UNINDEXED,
-      time_created UNINDEXED,
-      text,
-      tokenize='unicode61'
-    );
-    CREATE TABLE IF NOT EXISTS document_index(
-      id TEXT PRIMARY KEY,
-      message_id TEXT NOT NULL,
-      session_id TEXT NOT NULL,
-      session_title TEXT NOT NULL,
-      directory TEXT NOT NULL,
-      role TEXT NOT NULL,
-      part_type TEXT NOT NULL,
-      tool TEXT,
-      time_created INTEGER NOT NULL,
-      text TEXT NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS document_index_recent_idx
-      ON document_index(directory, role, time_created DESC);
-    CREATE INDEX IF NOT EXISTS document_index_recent_text_idx
-      ON document_index(directory, role, part_type, time_created DESC);
-    CREATE INDEX IF NOT EXISTS document_index_time_idx
-      ON document_index(time_created DESC);
-  `)
-
-  const columns = db.query<{ name: string }, []>("PRAGMA table_info(document_fts)").all().map((column) => column.name)
-  if (!columns.includes("part_type") || !columns.includes("tool")) {
-    db.exec("DROP TABLE document_fts")
-    db.exec(`
-      CREATE VIRTUAL TABLE document_fts USING fts5(
-        id UNINDEXED,
-        message_id UNINDEXED,
-        session_id UNINDEXED,
-        session_title,
-        directory UNINDEXED,
-        role UNINDEXED,
-        part_type UNINDEXED,
-        tool UNINDEXED,
-        time_created UNINDEXED,
-        text,
-        tokenize='unicode61'
-      );
-    `)
-  }
-
-  const indexColumns = db.query<{ name: string }, []>("PRAGMA table_info(document_index)").all().map((column) => column.name)
-  if (!["part_type", "tool", "time_created", "text"].every((name) => indexColumns.includes(name))) {
-    db.exec("DROP TABLE IF EXISTS document_index")
-    db.exec(`
-      CREATE TABLE document_index(
-        id TEXT PRIMARY KEY,
-        message_id TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        session_title TEXT NOT NULL,
-        directory TEXT NOT NULL,
-        role TEXT NOT NULL,
-        part_type TEXT NOT NULL,
-        tool TEXT,
-        time_created INTEGER NOT NULL,
-        text TEXT NOT NULL
-      );
-    `)
-  }
-  db.exec(`
-    CREATE INDEX IF NOT EXISTS document_index_recent_idx
-      ON document_index(directory, role, time_created DESC);
-    CREATE INDEX IF NOT EXISTS document_index_recent_text_idx
-      ON document_index(directory, role, part_type, time_created DESC);
-    CREATE INDEX IF NOT EXISTS document_index_time_idx
-      ON document_index(time_created DESC);
-  `)
-}
-
-function sourceState(db: Database, sourcePath: string) {
-  const stat = statSync(sourcePath)
-  const dataVersion = db.query<{ data_version: number }, []>("PRAGMA data_version").get()?.data_version ?? 0
-  return { dataVersion, mtimeMs: stat.mtimeMs }
-}
-
-function rebuildSearchIndex(source: Database, index: Database, sourcePath: string, state: { dataVersion: number; mtimeMs: number }) {
-  debug.time("fts:rebuild")
-  const rows = source.query<IndexSourceRow, []>(`
-    SELECT p.id, p.message_id, p.session_id, s.title AS session_title, s.directory,
-           json_extract(m.data, '$.role') AS role,
-           json_extract(p.data, '$.type') AS part_type,
-           json_extract(p.data, '$.tool') AS tool,
-           p.time_created,
-           p.data
-    FROM part p
-    JOIN message m ON m.id = p.message_id
-    JOIN session s ON s.id = p.session_id
-    WHERE (
-        json_extract(p.data, '$.type') = 'text'
-        OR (
-          json_extract(p.data, '$.type') = 'tool'
-          AND json_extract(p.data, '$.tool') IN ('apply_patch', 'edit', 'write')
-        )
-      )
-      AND json_extract(m.data, '$.role') IN ('user', 'assistant')
-    ORDER BY p.time_created DESC
-  `).all()
-  const now = Date.now()
-  const config = parseSemanticConfig()
-  const insertDoc = index.query<unknown, [string, string, string, string, string, string, string, string, string | null, number, number, string, string, string, number]>(`
-    INSERT INTO document(doc_id, part_id, message_id, session_id, session_title, directory, role, part_type, tool, time_created, chunk_index, text, source_hash, extractor_version, indexed_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `)
-  const insertFts = index.query<Row, [string, string, string, string, string, string, SearchResult["partType"], string | null, number, string]>(`
-    INSERT INTO document_fts(id, message_id, session_id, session_title, directory, role, part_type, tool, time_created, text)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `)
-  const insertIndex = index.query<Row, [string, string, string, string, string, string, SearchResult["partType"], string | null, number, string]>(`
-    INSERT INTO document_index(id, message_id, session_id, session_title, directory, role, part_type, tool, time_created, text)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `)
-  index.exec("BEGIN IMMEDIATE")
-  try {
-    index.exec("DELETE FROM document")
-    index.exec("DELETE FROM document_fts")
-    index.exec("DELETE FROM document_index")
-    for (const row of rows.flatMap(indexSourceRowToRows)) {
-      const docID = `telescope:${row.session_id}:${row.message_id}:${row.id}:0`
-      const sourceHash = hashPartData({ session_id: row.session_id, message_id: row.message_id, part_id: row.id })
-      insertDoc.run(
-        docID,
-        row.id,
-        row.message_id,
-        row.session_id,
-        row.session_title ?? "Untitled session",
-        row.directory,
-        row.role,
-        row.part_type ?? "text",
-        row.tool ?? null,
-        row.time_created,
-        0,
-        row.text,
-        sourceHash,
-        DOCUMENT_EXTRACTOR_VERSION,
-        now,
-      )
-      insertFts.run(
-        row.id,
-        row.message_id,
-        row.session_id,
-        row.session_title ?? "Untitled session",
-        row.directory,
-        row.role,
-        row.part_type ?? "text",
-        row.tool ?? null,
-        row.time_created,
-        row.text,
-      )
-      insertIndex.run(
-        row.id,
-        row.message_id,
-        row.session_id,
-        row.session_title ?? "Untitled session",
-        row.directory,
-        row.role,
-        row.part_type ?? "text",
-        row.tool ?? null,
-        row.time_created,
-        row.text,
-      )
-    }
-    setMeta(index, "source_path", sourcePath)
-    setMeta(index, "source_data_version", String(state.dataVersion))
-    setMeta(index, "source_mtime_ms", String(state.mtimeMs))
-    setMeta(index, "index_version", SEARCH_INDEX_VERSION)
-    setMeta(index, "schema_version", "2")
-    setMeta(index, "extractor_version", DOCUMENT_EXTRACTOR_VERSION)
-    setMeta(index, "ranking_version", "1")
-    setMeta(index, "embedding_base_url", config.embedBaseUrl)
-    setMeta(index, "document_prefix", config.documentPrefix)
-    setMeta(index, "query_prefix", config.queryPrefix)
-    if (config.embedModel) setMeta(index, "embedding_model", config.embedModel)
-    index.exec("COMMIT")
-  } catch (err) {
-    index.exec("ROLLBACK")
-    throw err
-  } finally {
-    debug.timeEnd("fts:rebuild")
-  }
-
-  if (config.disableVector) {
-    setMeta(index, "vector_state", "disabled")
-  } else {
-    setupVectorTable(index, config, searchIndexPath(sourcePath))
-  }
-}
-
-function hashPartData(value: { session_id: string; message_id: string; part_id: string }) {
-  return createHash("sha256").update(`${value.session_id}:${value.message_id}:${value.part_id}`).digest("hex")
-}
-
-let customSQLiteConfigured = false
-
-function configureCustomSQLite() {
-  if (customSQLiteConfigured) return
-  const config = parseSemanticConfig()
-  if (config.disableVector) return
-  customSQLiteConfigured = true
-
-  const candidates = [
-    config.sqliteLibPath,
-    process.platform === "darwin" ? "/opt/homebrew/opt/sqlite/lib/libsqlite3.dylib" : undefined,
-    process.platform === "darwin" ? "/usr/local/opt/sqlite/lib/libsqlite3.dylib" : undefined,
-  ].filter((item): item is string => Boolean(item))
-
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      try {
-        Database.setCustomSQLite(candidate)
-        debug.log("custom-sqlite:set", { path: candidate })
-        return
-      } catch (err) {
-        debug.log("custom-sqlite:error", { path: candidate, error: err instanceof Error ? err.message : String(err) })
-      }
-    }
-  }
-}
-
-function importPackage(specifier: string) {
-  return new Function("specifier", "return import(specifier)")(specifier) as Promise<{ default?: { load?: (db: Database) => void } }>
-}
-
-async function loadVecExtension(db: Database): Promise<boolean> {
-  try {
-    const sqliteVec = await importPackage("sqlite-vec").catch(() => undefined)
-    if (sqliteVec?.default?.load) {
-      sqliteVec.default.load(db)
-      debug.log("vector:extension:loaded", { source: "npm" })
-      return true
-    }
-  } catch {
-    debug.log("vector:extension:npm-failed")
-  }
-
-  const config = parseSemanticConfig()
-  const explicitPath = config.sqliteVecExtension || process.env.OPENCODE_TELESCOPE_SQLITE_VEC_EXT
-  if (explicitPath && existsSync(explicitPath)) {
-    try {
-      db.loadExtension(explicitPath)
-      debug.log("vector:extension:loaded", { source: "path", path: explicitPath })
-      return true
-    } catch (err) {
-      debug.log("vector:extension:path-failed", { path: explicitPath, error: err instanceof Error ? err.message : String(err) })
-    }
-  }
-
-  return false
-}
-
-function setupVectorTable(index: Database, config: SemanticConfig, indexPath: string) {
-  setMeta(index, "vector_state", "stale")
-  rebuildVectorIndex(indexPath, config).catch((err: Error) => {
-    debug.log("vector:rebuild:error", err instanceof Error ? err.message : String(err))
-  })
-}
-
-async function rebuildVectorIndex(indexPath: string, config: SemanticConfig) {
-  configureCustomSQLite()
-  const db = new Database(indexPath)
-  try {
-    const loaded = await loadVecExtension(db)
-    if (!loaded) {
-      setMeta(db, "vector_state", "unavailable")
-      return
-    }
-
-    const client = new LlamaEmbeddingClient({
-      baseUrl: config.embedBaseUrl,
-      model: config.embedModel,
-      documentPrefix: config.documentPrefix,
-      queryPrefix: config.queryPrefix,
-    })
-    const healthy = await client.health()
-    if (!healthy) {
-      setMeta(db, "vector_state", "unavailable")
-      return
-    }
-
-    const docs = db.query<{ rowid: number; text: string }, []>("SELECT rowid, text FROM document ORDER BY rowid ASC").all()
-    if (!docs.length) {
-      setMeta(db, "vector_state", "enabled")
-      return
-    }
-
-    debug.log("vector:embed:start", { count: docs.length })
-    const embeddings = await client.embedDocuments(docs.map((d) => d.text))
-    const dims = embeddings[0]?.length
-    if (!dims) {
-      setMeta(db, "vector_state", "unavailable")
-      return
-    }
-
-    db.exec("DROP TABLE IF EXISTS document_vec")
-    db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS document_vec USING vec0(embedding float[${dims}])`)
-    debug.log("vector:table:recreated", { dimensions: dims })
-
-    const insert = db.prepare<unknown, [number, Float32Array]>("INSERT INTO document_vec(rowid, embedding) VALUES (?, vec_f32(?))")
-    const transaction = db.transaction(() => {
-      for (const [i, doc] of docs.entries()) {
-        insert.run(doc.rowid, embeddings[i])
-      }
-    })
-    transaction()
-
-    setMeta(db, "vector_state", "enabled")
-    setMeta(db, "embedding_dimensions", String(dims))
-    if (config.embedModel) setMeta(db, "embedding_model", config.embedModel)
-    debug.log("vector:rebuild:done", { vectors: docs.length, dimensions: dims })
-  } catch (err) {
-    setMeta(db, "vector_state", "unavailable")
-    debug.log("vector:rebuild:error", err instanceof Error ? err.message : String(err))
-  } finally {
-    db.close()
-  }
-}
-
-export type ScoredRow = Row & {
-  score: number
-  keywordScore: number
-  vectorScore: number
-}
-
-function searchVector(index: Database, embedding: Float32Array, limit: number): Row[] {
-  const count = index.query<{ count: number }, []>("SELECT COUNT(*) as count FROM document_vec").get()?.count ?? 0
-  if (!count) return []
-  const k = Math.min(count, Math.max(limit * 4, 200))
-  return index.query<Row, [Float32Array, number]>(`
-    SELECT d.part_id AS id, d.message_id, d.session_id, d.session_title, d.directory, d.role,
-           d.part_type, d.tool, CAST(d.time_created AS INTEGER) AS time_created, d.text
-    FROM document_vec v
-    JOIN document d ON d.rowid = v.rowid
-    WHERE v.embedding MATCH vec_f32(?) AND k = ?
-    ORDER BY v.distance
-  `).all(embedding, k)
-}
-
-export function hybridBlend(keyword: Row[], vector: Row[], alpha: number): ScoredRow[] {
-  const merged = new Map<string, ScoredRow>()
-  const defaultScore = 1 / Math.max(keyword.length, 1)
-
-  for (const [i, row] of keyword.entries()) {
-    merged.set(row.id, {
-      ...row,
-      score: 0,
-      keywordScore: keyword.length > 1 ? 1 - i / (keyword.length - 1) : 1,
-      vectorScore: 0,
-    })
-  }
-
-  for (const [i, row] of vector.entries()) {
-    const existing = merged.get(row.id)
-    const vectorScore = vector.length > 1 ? 1 - i / (vector.length - 1) : 1
-    if (existing) {
-      existing.vectorScore = vectorScore
-    } else {
-      merged.set(row.id, {
-        ...row,
-        score: 0,
-        keywordScore: defaultScore,
-        vectorScore,
-      })
-    }
-  }
-
-  const keywordValues = [...merged.values()].map((r) => r.keywordScore)
-  const vectorValues = [...merged.values()].map((r) => r.vectorScore)
-  const kwMin = Math.min(...keywordValues)
-  const kwMax = Math.max(...keywordValues)
-  const vecMin = Math.min(...vectorValues)
-  const vecMax = Math.max(...vectorValues)
-
-  const normalized = [...merged.values()].map((r) => {
-    const kn = kwMax === kwMin ? 0.5 : (r.keywordScore - kwMin) / (kwMax - kwMin)
-    const vn = vecMax === vecMin ? 0.5 : (r.vectorScore - vecMin) / (vecMax - vecMin)
-    return {
-      ...r,
-      keywordScore: kn,
-      vectorScore: vn,
-      score: (1 - alpha) * kn + alpha * vn,
-    }
-  })
-
-  return normalized.sort((a, b) => b.score - a.score)
-}
-
-export type HybridSearchOptions = {
-  limit?: number
-  offset?: number
-  directory?: string
-  role?: SearchRole
-  dbPath?: string
-}
-
-export async function performSearch(query: string, options?: HybridSearchOptions): Promise<SearchResult[]> {
-  if (!query.trim()) return searchSessionMessages(query, options)
-  const config = parseSemanticConfig()
-  if (!config.disableVector) {
-    try {
-      return await semanticSearchSessionMessages(query, options)
-    } catch {
-      debug.log("query:hybrid:fallback", { message: "hybrid search failed, falling back to keyword" })
-    }
-  }
-  return searchSessionMessages(query, options)
-}
-
-export async function semanticSearchSessionMessages(query: string, options?: HybridSearchOptions): Promise<SearchResult[]> {
-  const term = query.trim()
-  if (!term) return []
-  if (options?.dbPath === ":memory:") return []
-  const dbPath = options?.dbPath ?? resolveDatabasePath()
-  const db = getDb(dbPath)
-  const limit = options?.limit ?? 80
-  const dir = options?.directory
-  const role = options?.role
-
-  const index = ensureSearchIndex(db, dbPath)
-  if (!index) return []
-
-  const keyword = indexedTextRows(db, dbPath, limit, term, dir, options?.offset, role) ?? []
-  const config = parseSemanticConfig()
-
-  let vector: Row[] = []
-  if (!config.disableVector) {
-    const vecState = getMeta(index, "vector_state")
-    if (vecState === "enabled") {
-      try {
-        const client = new LlamaEmbeddingClient({
-          baseUrl: config.embedBaseUrl,
-          model: config.embedModel,
-          documentPrefix: config.documentPrefix,
-          queryPrefix: config.queryPrefix,
-        })
-        const embedding = await client.embedQuery(term)
-        vector = searchVector(index, embedding, limit)
-        debug.log("query:vector:results", { count: vector.length })
-      } catch (err) {
-        debug.log("query:vector:error", err instanceof Error ? err.message : String(err))
-      }
-    }
-  }
-
-  const merged = keyword.length || vector.length
-    ? hybridBlend(keyword, vector, config.hybridAlpha)
-    : []
-
-  const results: SearchResult[] = []
-  const seen = new Set<string>()
-  for (const row of merged) {
-    const result = rowToSearchResult(row, term) ?? rowToVectorResult(row)
-    if (result) {
-      seen.add(row.id)
-      results.push(result)
-    }
-  }
-
-  for (const row of vector) {
-    if (!seen.has(row.id)) {
-      const result = rowToSearchResult(row, term) ?? rowToVectorResult(row)
-      if (result) results.push(result)
-    }
-  }
-
-  return results
-}
-
-export function rowToVectorResult(row: Row): SearchResult | undefined {
-  const text = row.text.trim()
-  if (!text) return
-  const excerpt = text.slice(0, 200)
-  return {
-    id: row.id,
-    messageID: row.message_id,
-    sessionID: row.session_id,
-    sessionTitle: row.session_title || "Untitled session",
-    directory: row.directory,
-    role: row.role,
-    partType: row.part_type ?? "text",
-    tool: row.tool ?? undefined,
-    timeCreated: row.time_created,
-    snippet: excerpt,
-    matchStart: -1,
-    matchEnd: -1,
-    before: "",
-    match: "",
-    after: excerpt,
-    excerpt,
-    previewBefore: text.slice(0, Math.min(text.length, 1400)),
-    previewMatch: "",
-    previewAfter: "",
-    previewMode: "markdown" as const,
-    previewHighlight: false,
-    text,
-  }
-}
-
-function ftsQuery(query: string) {
-  const tokens = query.trim().split(/\s+/)
-    .map((token) => token.replace(/["*^:()]/g, " ").trim())
-    .filter(Boolean)
-  if (!tokens.length) return ""
-  return tokens.map((token) => `"${token.replace(/"/g, '""')}"*`).join(" AND ")
-}
-
-function getMeta(db: Database, key: string) {
-  return db.query<{ value: string }, [string]>("SELECT value FROM index_meta WHERE key = ?").get(key)?.value
-}
-
-function setMeta(db: Database, key: string, value: string) {
-  db.query<unknown, [string, string]>(`
-    INSERT INTO index_meta(key, value) VALUES (?, ?)
-    ON CONFLICT(key) DO UPDATE SET value = excluded.value
-  `).run(key, value)
-}
-
-function indexSourceRowToRows(row: IndexSourceRow): Row[] {
-  const text = extractIndexText(row.data)
-  if (!text) return []
-  return [{ ...row, text }]
-}
-
-function extractIndexText(data: string) {
-  try {
-    const value = JSON.parse(data) as unknown
-    if (!value || typeof value !== "object" || Array.isArray(value)) return ""
-    const record = value as Record<string, unknown>
-    if (record.type === "text") return typeof record.text === "string" ? record.text.trim() : ""
-    if (record.type !== "tool") return ""
-    return extractToolIndexText(record).replace(/\s+/g, " ").trim()
-  } catch {
-    return ""
-  }
-}
-
-function extractToolIndexText(part: Record<string, unknown>) {
-  const tool = typeof part.tool === "string" ? part.tool : ""
-  const state = recordValue(part.state)
-  const input = recordValue(state?.input)
-  const metadata = recordValue(state?.metadata)
-
-  if (tool === "apply_patch") {
-    const files = Array.isArray(metadata?.files) ? metadata.files : []
-    const renderedPatches = files.map(applyPatchFileIndexText).filter(Boolean).join("\n")
-    const patchText = stringValue(input?.patchText)
-    return [renderedPatches, patchText].filter(Boolean).join("\n")
-  }
-
-  if (tool === "edit") {
-    const filediff = recordValue(metadata?.filediff)
-    return [
-      stringValue(input?.filePath),
-      stringValue(metadata?.diff),
-      stringValue(filediff?.patch),
-      stringValue(input?.oldString),
-      stringValue(input?.newString),
-    ].filter(Boolean).join("\n")
-  }
-
-  if (tool === "write") {
-    return [stringValue(input?.filePath), stringValue(input?.content)].filter(Boolean).join("\n")
-  }
-
-  return ""
-}
-
-function applyPatchFileIndexText(value: unknown) {
-  const file = recordValue(value)
-  if (!file) return ""
-  return [
-    stringValue(file.filePath),
-    stringValue(file.relativePath),
-    stringValue(file.patch),
-  ].filter(Boolean).join("\n")
-}
-
-function recordValue(value: unknown): Record<string, unknown> | undefined {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return
-  return value as Record<string, unknown>
-}
-
-function stringValue(value: unknown) {
-  return typeof value === "string" ? value : undefined
-}
-
-const tableCache = new Map<string, boolean>()
-function tableExists(db: Database, name: string) {
-  if (tableCache.has(name)) return tableCache.get(name)!
-  const exists = Boolean(db.query<{ name: string }, [string]>("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(name))
-  tableCache.set(name, exists)
-  return exists
-}
-
-function defaultDataDir() {
-  if (process.env.XDG_DATA_HOME) return path.join(process.env.XDG_DATA_HOME, "opencode")
-  return path.join(homedir(), ".local", "share", "opencode")
-}
-
-function candidateDataDirs() {
-  return [
-    defaultDataDir(),
-    path.join(homedir(), ".local", "share", "opencode"),
-    process.platform === "darwin" ? path.join(homedir(), "Library", "Application Support", "opencode") : undefined,
-    process.platform === "win32" ? path.join(process.env.APPDATA ?? path.join(homedir(), "AppData", "Roaming"), "opencode") : undefined,
-  ].filter((item, index, list): item is string => Boolean(item) && list.indexOf(item) === index)
-}
-
-function candidateDatabasePaths(names: string[]) {
-  return candidateDataDirs().flatMap((dir) => names.map((name) => path.join(dir, name)))
-}
-
-function requireExistingDatabase(names: string[]) {
-  return candidateDatabasePaths(names).find(existsSync) ?? candidateDatabasePaths(names)[0]!
-}
-
-function extractFromValue(value: unknown): string {
-  if (typeof value === "string") return value
-  if (typeof value === "number" || typeof value === "boolean") return String(value)
-  if (!value) return ""
-  if (Array.isArray(value)) return value.map(extractFromValue).filter(Boolean).join("\n")
-  if (typeof value !== "object") return ""
-  return Object.entries(value)
-    .filter(([key]) => !["id", "sessionID", "messageID", "time", "timeCreated", "timeUpdated", "tokens", "cost"].includes(key))
-    .map(([, item]) => extractFromValue(item))
-    .filter(Boolean)
-    .join("\n")
-}
-
-function truncate(value: string, length: number) {
-  if (value.length <= length) return value
-  return `${value.slice(0, length - 3)}...`
-}
+// Re-exported types
+export type {
+  SearchResult,
+  SearchRole,
+  ConversationPreviewPart,
+  ConversationPreviewPage,
+  ConversationPreviewCursor,
+  ToolState,
+  SemanticConfig,
+  VectorState,
+  DocumentRow,
+  ScoredRow,
+  HybridSearchOptions,
+} from "./search/types.ts"
+
+// Re-exported query functions
+export {
+  searchSessionMessages,
+  recentSessionMessages,
+  loadConversationAround,
+  loadConversationBefore,
+  loadConversationAfter,
+  performSearch,
+  semanticSearchSessionMessages,
+  parseSemanticConfig,
+} from "./search/queries.ts"
+
+// Re-exported text/snippet functions
+export {
+  rowToSearchResult,
+  rowToVectorResult,
+  makeSnippet,
+  extractSearchText,
+  ftsQuery,
+  expandQuery,
+} from "./search/text.ts"
+
+// Re-exported vector/blend functions
+export {
+  hybridBlend,
+} from "./search/vector.ts"
+
+// Re-exported path utilities
+export {
+  resolveDatabasePath,
+  searchIndexPath,
+} from "./search/db-path.ts"