@bojackduy/opencode-telescope 0.1.24 → 0.1.25

package/search/schema.ts

@@ -0,0 +1,120 @@
+import { Database } from "bun:sqlite"
+
+export const SEARCH_INDEX_VERSION = "7"
+export const DOCUMENT_EXTRACTOR_VERSION = "1"
+
+export 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);
+  `)
+}
+
+export function getMeta(db: Database, key: string) {
+  return db.query<{ value: string }, [string]>("SELECT value FROM index_meta WHERE key = ?").get(key)?.value
+}
+
+export 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)
+}

package/search/text.ts

@@ -0,0 +1,348 @@
+import type { IndexSourceRow, Row, SearchResult } from "./types.ts"
+
+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,
+    isVectorMatch: false,
+    semanticScore: 0,
+  }
+}
+
+export function rowToVectorResult(row: Row, vectorScore = 0): 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,
+    isVectorMatch: true,
+    semanticScore: vectorScore,
+  }
+}
+
+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 ? "..." : ""}`
+}
+
+export function extractSearchText(data: string) {
+  try {
+    return extractFromValue(JSON.parse(data)).replace(/\s+/g, " ").trim()
+  } catch {
+    return data.replace(/\s+/g, " ").trim()
+  }
+}
+
+export 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 ""
+  }
+}
+
+export function indexSourceRowToRows(row: IndexSourceRow): Row[] {
+  const text = extractIndexText(row.data)
+  if (!text) return []
+  return [{ ...row, text }]
+}
+
+export 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 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 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 normalizeSnippetSegment(value: string) {
+  return value.replace(/\s+/g, " ")
+}
+
+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 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
+}
+
+function truncate(value: string, length: number) {
+  if (value.length <= length) return value
+  return `${value.slice(0, length - 3)}...`
+}
+
+const synonymMap: Record<string, string[]> = {
+  greeting: ["hello", "hi", "hey", "howdy", "greetings", "good morning", "good afternoon", "good evening"],
+  hello: ["hi", "hey", "howdy", "greeting", "greetings"],
+  hi: ["hello", "hey", "howdy", "greeting"],
+  hey: ["hello", "hi", "howdy", "greeting"],
+  thanks: ["thank you", "thx", "ty", "appreciate", "grateful"],
+  goodbye: ["bye", "see you", "farewell", "later", "cya"],
+  bye: ["goodbye", "see you", "farewell", "later"],
+  error: ["bug", "issue", "failed", "failure", "problem", "exception"],
+  bug: ["error", "issue", "problem", "defect"],
+  fix: ["repair", "patch", "resolve", "correct", "solve", "bugfix"],
+  help: ["assist", "support", "guide", "how to", "tutorial"],
+  explain: ["describe", "clarify", "elaborate", "what is", "how does"],
+  code: ["program", "source", "implementation", "script", "function"],
+  test: ["spec", "unit test", "assertion", "verify", "check"],
+  refactor: ["restructure", "rewrite", "improve", "reorganize", "clean up"],
+  optimize: ["improve", "speed up", "performance", "efficient", "fast"],
+  config: ["configuration", "setting", "option", "setup"],
+  deploy: ["release", "publish", "ship", "rollout", "launch"],
+  security: ["auth", "permission", "access", "vulnerability", "secure"],
+  database: ["db", "sql", "query", "schema", "storage", "persist"],
+}
+
+export function expandQuery(query: string): string {
+  const trimmed = query.trim()
+  const tokens = trimmed.toLowerCase().split(/\s+/).filter(Boolean)
+  if (tokens.length > 1) return trimmed
+  const word = tokens[0]
+  if (!word) return trimmed
+  const synonyms = synonymMap[word]
+  if (!synonyms) return trimmed
+  const seen = new Set([word])
+  const expanded = [trimmed]
+  for (const syn of synonyms) {
+    const key = syn.toLowerCase()
+    if (!seen.has(key)) {
+      expanded.push(syn)
+      seen.add(key)
+    }
+  }
+  return expanded.join(" ")
+}

package/search/types.ts

@@ -0,0 +1,131 @@
+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
+  isVectorMatch: boolean
+  semanticScore: number
+}
+
+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 type ScoredRow = Row & {
+  score: number
+  keywordScore: number
+  vectorScore: number
+}
+
+export type HybridSearchOptions = {
+  limit?: number
+  offset?: number
+  directory?: string
+  role?: SearchRole
+  dbPath?: 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
+}
+
+export 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
+}
+
+export type IndexSourceRow = Omit<Row, "text"> & {
+  data: string
+}
+
+export type ConversationRow = {
+  id: string
+  message_id: string
+  session_id: string
+  role: SearchRole
+  type: "text" | "reasoning" | "tool"
+  time_created: number
+  data: string
+}