@bojackduy/opencode-telescope 0.1.16 → 0.1.18

package/components/preview.tsx

@@ -59,7 +59,7 @@ export const ConversationPreview = (props: { item: SearchResult; parts: Conversa
 )
 
 const PreviewConversationPart = (props: { part: ConversationPreviewPart; item: SearchResult; syntax: SyntaxStyle; theme: TuiThemeCurrent }) => {
-  if (props.part.type === "tool") return <PreviewToolPart part={props.part} theme={props.theme} />
+  if (props.part.type === "tool") return <PreviewToolPart part={props.part} item={props.item} syntax={props.syntax} theme={props.theme} />
   if (props.part.type === "reasoning") return <PreviewReasoningPart part={props.part} syntax={props.syntax} theme={props.theme} />
   if (props.part.role === "assistant") return <PreviewAssistantPart part={props.part} item={props.item} syntax={props.syntax} theme={props.theme} />
   return <PreviewUserPart part={props.part} item={props.item} theme={props.theme} />
@@ -129,7 +129,7 @@ const PreviewReasoningPart = (props: { part: ConversationPreviewPart; syntax: Sy
   )
 }
 
-const PreviewToolPart = (props: { part: ConversationPreviewPart; theme: TuiThemeCurrent }) => {
+const PreviewToolPart = (props: { part: ConversationPreviewPart; item: SearchResult; syntax: SyntaxStyle; theme: TuiThemeCurrent }) => {
   const status = createMemo(() => props.part.state?.status ?? "pending")
   const failed = createMemo(() => status() === "error")
   const color = createMemo(() => {
@@ -137,27 +137,169 @@ const PreviewToolPart = (props: { part: ConversationPreviewPart; theme: TuiTheme
     if (status() === "completed") return props.theme.textMuted
     return props.theme.text
   })
+  const codeTool = createMemo(() => props.part.tool === "apply_patch" || props.part.tool === "edit" || props.part.tool === "write")
   return (
-    <box id={`tool-inline-${props.part.messageID}-${props.part.id}`} paddingLeft={3} marginTop={1} flexDirection="column" flexShrink={0}>
+    <box id={`tool-${props.part.messageID}-${props.part.id}`} paddingLeft={3} marginTop={1} flexDirection="column" flexShrink={0}>
       <Show when={props.part.target}>
-        <TargetMarker part={props.part} role="tool" time={props.part.timeCreated} theme={props.theme} />
+        <TargetMarker part={props.part} item={props.item} role={props.part.tool ?? "tool"} time={props.part.timeCreated} theme={props.theme} />
+      </Show>
+      <Show when={codeTool() && props.part.target} fallback={<CompactToolRow part={props.part} color={color()} failed={failed()} theme={props.theme} />}>
+        <CodeToolPreview part={props.part} item={props.item} syntax={props.syntax} theme={props.theme} />
       </Show>
-      <text fg={color()} wrapMode="none" overflow="hidden">
-        <span style={{ fg: failed() ? props.theme.error : props.theme.textMuted }}>{toolIcon(props.part.tool)} </span>
-        <span>{toolLabel(props.part.tool)}</span>
-        <span style={{ fg: props.theme.textMuted }}> {toolInputSummary(props.part.state?.input)}</span>
-        <span style={{ fg: props.theme.textMuted }}> · {status()}</span>
-      </text>
       <Show when={props.part.state?.error}>
         {(error) => <text fg={props.theme.error}>{error()}</text>}
       </Show>
-      <Show when={failed() ? props.part.state?.output : undefined}>
-        {(output) => <text fg={props.theme.textMuted}>{truncate(output().trim(), 300)}</text>}
-      </Show>
     </box>
   )
 }
 
+const CompactToolRow = (props: { part: ConversationPreviewPart; color: any; failed: boolean; theme: TuiThemeCurrent }) => (
+  <>
+    <text fg={props.color} wrapMode="none" overflow="hidden">
+      <span style={{ fg: props.failed ? props.theme.error : props.theme.textMuted }}>{toolIcon(props.part.tool)} </span>
+      <span>{toolLabel(props.part.tool)}</span>
+      <span style={{ fg: props.theme.textMuted }}> {toolInputSummary(props.part.state?.input)}</span>
+      <span style={{ fg: props.theme.textMuted }}> · {props.part.state?.status ?? "pending"}</span>
+    </text>
+    <Show when={props.failed ? props.part.state?.output : undefined}>
+      {(output) => <text fg={props.theme.textMuted}>{truncate(output().trim(), 300)}</text>}
+    </Show>
+  </>
+)
+
+const CodeToolPreview = (props: { part: ConversationPreviewPart; item: SearchResult; syntax: SyntaxStyle; theme: TuiThemeCurrent }) => {
+  if (props.part.tool === "apply_patch") return <ApplyPatchPreview part={props.part} item={props.item} syntax={props.syntax} theme={props.theme} />
+  if (props.part.tool === "edit") return <EditPreview part={props.part} item={props.item} syntax={props.syntax} theme={props.theme} />
+  if (props.part.tool === "write") return <WritePreview part={props.part} item={props.item} syntax={props.syntax} theme={props.theme} />
+  return <CompactToolRow part={props.part} color={props.theme.textMuted} failed={false} theme={props.theme} />
+}
+
+const ApplyPatchPreview = (props: { part: ConversationPreviewPart; item: SearchResult; syntax: SyntaxStyle; theme: TuiThemeCurrent }) => {
+  const files = createMemo(() => parseApplyPatchFiles(props.part.state?.metadata))
+  const matched = createMemo(() => {
+    const query = props.item.match || props.item.previewMatch
+    return files().find((file) => containsOrderedTokens(file.patch, query)) ?? files()[0]
+  })
+  return (
+    <Show when={matched()} fallback={<CompactToolRow part={props.part} color={props.theme.textMuted} failed={false} theme={props.theme} />}>
+      {(file) => {
+        const view = createMemo(() => clippedText(file().patch, props.item.match || props.item.previewMatch, 24))
+        return (
+          <ToolBlock title={patchTitle(file())} theme={props.theme}>
+            <Show when={view().clipped}>
+              <text fg={props.theme.textMuted}>showing matched excerpt from large patch</text>
+            </Show>
+            <DiffBlock diff={view().text} filePath={file().filePath} syntax={props.syntax} theme={props.theme} clipped={view().clipped} />
+          </ToolBlock>
+        )
+      }}
+    </Show>
+  )
+}
+
+const EditPreview = (props: { part: ConversationPreviewPart; item: SearchResult; syntax: SyntaxStyle; theme: TuiThemeCurrent }) => {
+  const input = createMemo(() => recordValue(props.part.state?.input))
+  const metadata = createMemo(() => recordValue(props.part.state?.metadata))
+  const diff = createMemo(() => stringValue(metadata()?.diff) ?? stringValue(recordValue(metadata()?.filediff)?.patch) ?? "")
+  const filePath = createMemo(() => stringValue(input()?.filePath) ?? stringValue(recordValue(metadata()?.filediff)?.file) ?? "")
+  return (
+    <Show when={diff()} fallback={<CompactToolRow part={props.part} color={props.theme.textMuted} failed={false} theme={props.theme} />}>
+      {(value) => (
+        <ToolBlock title={`← Edit ${shortPath(filePath())}`} theme={props.theme}>
+          {(() => {
+            const view = createMemo(() => clippedText(value(), props.item.match || props.item.previewMatch, 24))
+            return (
+              <>
+                <Show when={view().clipped}>
+                  <text fg={props.theme.textMuted}>showing matched excerpt from large diff</text>
+                </Show>
+                <DiffBlock diff={view().text} filePath={filePath()} syntax={props.syntax} theme={props.theme} clipped={view().clipped} />
+              </>
+            )
+          })()}
+        </ToolBlock>
+      )}
+    </Show>
+  )
+}
+
+const WritePreview = (props: { part: ConversationPreviewPart; item: SearchResult; syntax: SyntaxStyle; theme: TuiThemeCurrent }) => {
+  const input = createMemo(() => recordValue(props.part.state?.input))
+  const filePath = createMemo(() => stringValue(input()?.filePath) ?? "")
+  const content = createMemo(() => stringValue(input()?.content) ?? "")
+  return (
+    <Show when={content()} fallback={<CompactToolRow part={props.part} color={props.theme.textMuted} failed={false} theme={props.theme} />}>
+      {(value) => (
+        <ToolBlock title={`# Wrote ${shortPath(filePath())}`} theme={props.theme}>
+          {(() => {
+            const view = createMemo(() => clippedText(value(), props.item.match || props.item.previewMatch, 32))
+            return (
+              <>
+                <Show when={view().clipped}>
+                  <text fg={props.theme.textMuted}>showing matched excerpt from large file</text>
+                </Show>
+          <line_number fg={props.theme.textMuted} minWidth={3} paddingRight={1}>
+            <code
+              conceal={false}
+              fg={props.theme.text}
+              filetype={filetype(filePath())}
+              syntaxStyle={props.syntax}
+              content={view().text}
+            />
+          </line_number>
+              </>
+            )
+          })()}
+        </ToolBlock>
+      )}
+    </Show>
+  )
+}
+
+const ToolBlock = (props: { title: string; children: any; theme: TuiThemeCurrent }) => (
+  <box
+    border={["left"]}
+    paddingTop={1}
+    paddingBottom={1}
+    paddingLeft={2}
+    marginTop={1}
+    gap={1}
+    backgroundColor={props.theme.backgroundPanel}
+    customBorderChars={splitBorderChars}
+    borderColor={props.theme.background}
+    flexDirection="column"
+  >
+    <text paddingLeft={3} fg={props.theme.textMuted}>{props.title}</text>
+    {props.children}
+  </box>
+)
+
+const DiffBlock = (props: { diff: string; filePath: string; syntax: SyntaxStyle; theme: TuiThemeCurrent; clipped?: boolean }) => (
+  <box paddingLeft={1}>
+    <Show when={!props.clipped} fallback={<code filetype="diff" syntaxStyle={props.syntax} content={props.diff} fg={props.theme.text} />}>
+      <diff
+        diff={props.diff}
+        view="unified"
+        filetype={filetype(props.filePath)}
+        syntaxStyle={props.syntax}
+        showLineNumbers={true}
+        width="100%"
+        wrapMode="word"
+        fg={props.theme.text}
+        addedBg={props.theme.diffAddedBg}
+        removedBg={props.theme.diffRemovedBg}
+        contextBg={props.theme.diffContextBg}
+        addedSignColor={props.theme.diffHighlightAdded}
+        removedSignColor={props.theme.diffHighlightRemoved}
+        lineNumberFg={props.theme.diffLineNumber}
+        lineNumberBg={props.theme.diffContextBg}
+        addedLineNumberBg={props.theme.diffAddedLineNumberBg}
+        removedLineNumberBg={props.theme.diffRemovedLineNumberBg}
+      />
+    </Show>
+  </box>
+)
+
 const TargetMarker = (props: { part: ConversationPreviewPart; item?: SearchResult; role: string; time: number; theme: TuiThemeCurrent }) => (
   <box flexDirection="column" flexShrink={0}>
     <text fg={props.theme.warning} wrapMode="none" overflow="hidden">
@@ -273,3 +415,106 @@ function matchExcerpt(text: string, query: string, radius = 80) {
     after: `${text.slice(lastEnd, afterEnd).replace(/\s+/g, " ")}${afterEnd < text.length ? "..." : ""}`,
   }
 }
+
+function clippedText(text: string, query: string, radiusLines: number) {
+  const lines = text.split("\n")
+  const tooLarge = text.length > 30000 || lines.length > 420
+  if (!tooLarge) return { text, clipped: false }
+
+  const matchLine = findOrderedTokenLine(lines, query)
+  if (matchLine === -1) {
+    return { text: lines.slice(0, radiusLines * 2).join("\n"), clipped: true }
+  }
+
+  const start = Math.max(0, matchLine - radiusLines)
+  const end = Math.min(lines.length, matchLine + radiusLines + 1)
+  return {
+    text: [
+      start > 0 ? `... ${start} lines omitted ...` : undefined,
+      ...lines.slice(start, end),
+      end < lines.length ? `... ${lines.length - end} lines omitted ...` : undefined,
+    ].filter(Boolean).join("\n"),
+    clipped: true,
+  }
+}
+
+function findOrderedTokenLine(lines: string[], query: string) {
+  const tokens = query.trim().split(/\s+/).filter(Boolean)
+  if (tokens.length === 0) return -1
+  for (let index = 0; index < lines.length; index++) {
+    if (containsOrderedTokens(lines[index]!, query)) return index
+  }
+  return -1
+}
+
+function containsOrderedTokens(text: string, query: string) {
+  const tokens = query.trim().split(/\s+/).filter(Boolean)
+  if (tokens.length === 0) return false
+  const lower = text.toLowerCase()
+  let searchPos = 0
+  for (const token of tokens) {
+    const index = lower.indexOf(token.toLowerCase(), searchPos)
+    if (index === -1) return false
+    searchPos = index + token.length
+  }
+  return true
+}
+
+function parseApplyPatchFiles(metadata: unknown) {
+  const files = recordValue(metadata)?.files
+  if (!Array.isArray(files)) return []
+  return files.flatMap((item) => {
+    const file = recordValue(item)
+    const filePath = stringValue(file?.filePath)
+    const relativePath = stringValue(file?.relativePath) ?? filePath
+    const patch = stringValue(file?.patch)
+    const type = stringValue(file?.type) ?? "update"
+    const deletions = numberValue(file?.deletions) ?? 0
+    if (!filePath || !relativePath || patch === undefined) return []
+    return [{ filePath, relativePath, patch, type, deletions }]
+  })
+}
+
+function patchTitle(file: { type: string; relativePath: string; filePath: string; deletions: number }) {
+  if (file.type === "delete") return `# Deleted ${file.relativePath}`
+  if (file.type === "add") return `# Created ${file.relativePath}`
+  if (file.type === "move") return `# Moved ${shortPath(file.filePath)} -> ${file.relativePath}`
+  return `← Patched ${file.relativePath}`
+}
+
+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 numberValue(value: unknown) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined
+}
+
+function shortPath(value: string) {
+  if (!value) return "file"
+  const parts = value.split(/[\\/]/)
+  return parts.slice(-3).join("/")
+}
+
+function filetype(input: string) {
+  const ext = input.split(".").at(-1)?.toLowerCase()
+  if (!ext || ext === input.toLowerCase()) return "none"
+  if (["ts", "tsx", "js", "jsx", "mts", "cts"].includes(ext)) return "typescript"
+  if (ext === "py") return "python"
+  if (ext === "go") return "go"
+  if (ext === "rs") return "rust"
+  if (ext === "rb") return "ruby"
+  if (ext === "java") return "java"
+  if (ext === "json") return "json"
+  if (ext === "md") return "markdown"
+  if (ext === "yml" || ext === "yaml") return "yaml"
+  if (ext === "sql") return "sql"
+  if (ext === "sh" || ext === "bash" || ext === "zsh") return "shellscript"
+  if (ext === "diff" || ext === "patch") return "diff"
+  return ext
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@bojackduy/opencode-telescope",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Fuzzy search across all OpenCode conversations — grep session and chat history, find code snippets, and jump to any chat instantly",
   "type": "module",
   "license": "MIT",

package/search.ts

@@ -11,6 +11,8 @@ export type SearchResult = {
   sessionTitle: string
   directory: string
   role: "user" | "assistant"
+  partType: "text" | "reasoning" | "tool"
+  tool?: string
   timeCreated: number
   snippet: string
   matchStart: number
@@ -56,6 +58,7 @@ export type ConversationPreviewCursor = {
 export type ToolState = {
   status: "pending" | "running" | "completed" | "error"
   input?: unknown
+  metadata?: unknown
   output?: string
   error?: string
 }
@@ -67,10 +70,16 @@ type Row = {
   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
+}
+
 type ConversationRow = {
   id: string
   message_id: string
@@ -222,7 +231,11 @@ export function loadConversationAround(result: SearchResult, options?: { before?
     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,
@@ -253,6 +266,7 @@ export function loadConversationBefore(result: SearchResult, cursor: Conversatio
   `).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,
@@ -261,7 +275,10 @@ export function loadConversationBefore(result: SearchResult, cursor: Conversatio
     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,
@@ -289,6 +306,7 @@ export function loadConversationAfter(result: SearchResult, cursor: Conversation
   `).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,
@@ -297,7 +315,10 @@ export function loadConversationAfter(result: SearchResult, cursor: Conversation
     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,
@@ -318,6 +339,8 @@ export function rowToSearchResult(row: Row, query: string): SearchResult | undef
     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,
@@ -490,7 +513,7 @@ function parseConversationPart(row: ConversationRow, target: boolean): Conversat
       role: row.role,
       type: row.type,
       timeCreated: row.time_created,
-      text: "",
+      text: target ? extractToolIndexText(data).trim() : "",
       tool: typeof data.tool === "string" ? data.tool : "tool",
       state: parseToolState(data.state),
       target,
@@ -515,6 +538,21 @@ function isPreviewRow(row: ConversationRow) {
     (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
@@ -532,6 +570,7 @@ function parseToolState(value: unknown): ToolState | undefined {
   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,
   }
@@ -568,7 +607,7 @@ function indexedTextRows(db: Database, dbPath: string, limit: number, query: str
     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,
+      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 ")}
@@ -638,15 +677,18 @@ function ensureSearchIndex(source: Database, sourcePath: string) {
   const currentDataVersion = getMeta(_indexDb, "source_data_version")
   const currentMtimeMs = getMeta(_indexDb, "source_mtime_ms")
   const currentPath = getMeta(_indexDb, "source_path")
-  if (currentPath !== sourcePath || currentDataVersion !== String(state.dataVersion) || currentMtimeMs !== String(state.mtimeMs)) {
+  const currentIndexVersion = getMeta(_indexDb, "index_version")
+  if (currentPath !== sourcePath || currentDataVersion !== String(state.dataVersion) || currentMtimeMs !== String(state.mtimeMs) || currentIndexVersion !== SEARCH_INDEX_VERSION) {
     rebuildSearchIndex(source, _indexDb, sourcePath, state)
   }
   return _indexDb
 }
 
+const SEARCH_INDEX_VERSION = "4"
+
 function searchIndexPath(sourcePath: string) {
   const parsed = path.parse(sourcePath)
-  return path.join(parsed.dir, `${parsed.name}-search.db`)
+  return path.join(parsed.dir, `${parsed.name}-telescope-search.db`)
 }
 
 function migrateSearchIndex(db: Database) {
@@ -662,11 +704,33 @@ function migrateSearchIndex(db: Database) {
       session_title,
       directory UNINDEXED,
       role UNINDEXED,
+      part_type UNINDEXED,
+      tool UNINDEXED,
       time_created UNINDEXED,
       text,
       tokenize='unicode61'
     );
   `)
+
+  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'
+      );
+    `)
+  }
 }
 
 function sourceState(db: Database, sourcePath: string) {
@@ -677,27 +741,34 @@ function sourceState(db: Database, sourcePath: string) {
 
 function rebuildSearchIndex(source: Database, index: Database, sourcePath: string, state: { dataVersion: number; mtimeMs: number }) {
   debug.time("fts:rebuild")
-  const rows = source.query<Row, []>(`
+  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,
-           json_extract(p.data, '$.text') AS text
+           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'
+    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')
-      AND json_extract(p.data, '$.text') IS NOT NULL
     ORDER BY p.time_created DESC
   `).all()
-  const insert = index.query<Row, [string, string, string, string, string, string, number, string]>(`
-    INSERT INTO document_fts(id, message_id, session_id, session_title, directory, role, time_created, text)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  const insert = 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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `)
   index.exec("BEGIN IMMEDIATE")
   try {
     index.exec("DELETE FROM document_fts")
-    for (const row of rows) {
+    for (const row of rows.flatMap(indexSourceRowToRows)) {
       insert.run(
         row.id,
         row.message_id,
@@ -705,6 +776,8 @@ function rebuildSearchIndex(source: Database, index: Database, sourcePath: strin
         row.session_title ?? "Untitled session",
         row.directory,
         row.role,
+        row.part_type ?? "text",
+        row.tool ?? null,
         row.time_created,
         row.text,
       )
@@ -712,6 +785,7 @@ function rebuildSearchIndex(source: Database, index: Database, sourcePath: strin
     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)
     index.exec("COMMIT")
   } catch (err) {
     index.exec("ROLLBACK")
@@ -740,6 +814,75 @@ function setMeta(db: Database, key: string, value: string) {
   `).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)!

package/telescope.tsx

@@ -432,18 +432,55 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
   })
 
   const previewContentHeight = () => {
-    const children = previewScroll?.getChildren()
+    return previewScroll?.scrollHeight ?? 0
+  }
+
+  const previewScrollState = () => {
+    const scroll = previewScroll
+    const children = scroll?.getChildren()
     const lastChild = children?.[children.length - 1] as { y: number; height: number } | undefined
-    return lastChild ? lastChild.y + lastChild.height : 0
+    return {
+      y: scroll?.y,
+      height: scroll?.height,
+      scrollTop: scroll?.scrollTop,
+      scrollHeight: scroll?.scrollHeight,
+      childContentHeight: lastChild ? lastChild.y + lastChild.height : 0,
+      children: children?.length ?? 0,
+      hasMoreBefore: hasMorePreviewBefore(),
+      hasMoreAfter: hasMorePreviewAfter(),
+      loadingMore: loadingPreviewMore(),
+      prefetchingBefore: prefetchingPreviewBefore(),
+      prefetchingAfter: prefetchingPreviewAfter(),
+      timerBefore: Boolean(previewBeforeTimer),
+      timerAfter: Boolean(previewAfterTimer),
+    }
   }
 
   const loadPreviewBefore = (previousContentHeight = previewContentHeight(), preserveScroll = true, visibleLoad = false) => {
     const item = selectedResult()
     const first = previewParts()[0]
-    if (!item || !first || loadingPreviewMore() || prefetchingPreviewBefore()) return
+    if (!item || !first || loadingPreviewMore() || prefetchingPreviewBefore()) {
+      debug.log("preview:load-before:skip", {
+        reason: !item ? "no-item" : !first ? "no-first-part" : loadingPreviewMore() ? "loading-preview-more" : "prefetching-before",
+        previousContentHeight,
+        preserveScroll,
+        visibleLoad,
+        state: previewScrollState(),
+      })
+      return
+    }
+    const beforeState = previewScrollState()
     visibleLoad ? setLoadingPreviewMore(true) : setPrefetchingPreviewBefore(true)
     debug.time("preview:load-before")
     try {
+      debug.log("preview:load-before:start", {
+        item: item.id,
+        cursor: { id: first.id, timeCreated: first.timeCreated },
+        previousContentHeight,
+        preserveScroll,
+        visibleLoad,
+        state: beforeState,
+      })
       const page = loadConversationBefore(item, { id: first.id, timeCreated: first.timeCreated }, { limit: PREVIEW_PAGE_SIZE, dbPath: dbPath() })
       debug.log("preview:load-before", {
         item: item.id,
@@ -458,8 +495,25 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
         setPreviewParts((prev) => [...page.parts, ...prev])
         if (preserveScroll) {
           setTimeout(() => {
+            const beforeAdjust = previewScrollState()
             const delta = previewContentHeight() - previousContentHeight
             if (delta > 0) previewScroll?.scrollBy(delta)
+            debug.log("preview:load-before:adjust", {
+              delta,
+              previousContentHeight,
+              newContentHeight: previewContentHeight(),
+              scrolled: delta > 0,
+              beforeAdjust,
+              afterAdjust: previewScrollState(),
+            })
+          }, 1)
+        } else {
+          setTimeout(() => {
+            debug.log("preview:load-before:no-adjust", {
+              previousContentHeight,
+              newContentHeight: previewContentHeight(),
+              state: previewScrollState(),
+            })
           }, 1)
         }
       }
@@ -475,7 +529,20 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
   const loadPreviewAfter = (visibleLoad = false) => {
     const item = selectedResult()
     const last = previewParts().at(-1)
-    if (!item || !last || loadingPreviewMore() || prefetchingPreviewAfter()) return
+    if (!item || !last || loadingPreviewMore() || prefetchingPreviewAfter()) {
+      debug.log("preview:load-after:skip", {
+        reason: !item ? "no-item" : !last ? "no-last-part" : loadingPreviewMore() ? "loading-preview-more" : "prefetching-after",
+        visibleLoad,
+        state: previewScrollState(),
+      })
+      return
+    }
+    debug.log("preview:load-after:start", {
+      item: item.id,
+      cursor: { id: last.id, timeCreated: last.timeCreated },
+      visibleLoad,
+      state: previewScrollState(),
+    })
     visibleLoad ? setLoadingPreviewMore(true) : setPrefetchingPreviewAfter(true)
     debug.time("preview:load-after")
     try {
@@ -499,16 +566,40 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
   }
 
   const schedulePreviewBefore = (previousContentHeight = previewContentHeight(), preserveScroll = true, visibleLoad = false) => {
-    if (!hasMorePreviewBefore() || loadingPreviewMore() || prefetchingPreviewBefore()) return
+    if (!hasMorePreviewBefore() || loadingPreviewMore() || prefetchingPreviewBefore()) {
+      debug.log("preview:prefetch-before:skip", {
+        reason: !hasMorePreviewBefore() ? "no-more-before" : loadingPreviewMore() ? "loading-preview-more" : "prefetching-before",
+        previousContentHeight,
+        preserveScroll,
+        visibleLoad,
+        state: previewScrollState(),
+      })
+      return
+    }
     if (previewBeforeTimer) {
       if (pendingPreviewBefore) {
+        const previousPending = { ...pendingPreviewBefore }
         pendingPreviewBefore.preserveScroll = pendingPreviewBefore.preserveScroll && preserveScroll
         pendingPreviewBefore.visibleLoad = pendingPreviewBefore.visibleLoad || visibleLoad
+        debug.log("preview:prefetch-before:merge", {
+          previousPending,
+          nextPending: pendingPreviewBefore,
+          requested: { previousContentHeight, preserveScroll, visibleLoad },
+          state: previewScrollState(),
+        })
+      } else {
+        debug.log("preview:prefetch-before:skip", {
+          reason: "timer-already-set",
+          previousContentHeight,
+          preserveScroll,
+          visibleLoad,
+          state: previewScrollState(),
+        })
       }
       return
     }
     pendingPreviewBefore = { previousContentHeight, preserveScroll, visibleLoad }
-    debug.log("preview:prefetch-before-scheduled", { preserveScroll, visibleLoad })
+    debug.log("preview:prefetch-before-scheduled", { previousContentHeight, preserveScroll, visibleLoad, state: previewScrollState() })
     previewBeforeTimer = setTimeout(() => {
       const pending = pendingPreviewBefore
       previewBeforeTimer = undefined
@@ -518,10 +609,20 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
   }
 
   const schedulePreviewAfter = (visibleLoad = false) => {
-    if (!hasMorePreviewAfter() || loadingPreviewMore() || prefetchingPreviewAfter()) return
+    if (!hasMorePreviewAfter() || loadingPreviewMore() || prefetchingPreviewAfter()) {
+      debug.log("preview:prefetch-after:skip", {
+        reason: !hasMorePreviewAfter() ? "no-more-after" : loadingPreviewMore() ? "loading-preview-more" : "prefetching-after",
+        visibleLoad,
+        state: previewScrollState(),
+      })
+      return
+    }
     pendingPreviewAfterVisible = pendingPreviewAfterVisible || visibleLoad
-    if (previewAfterTimer) return
-    debug.log("preview:prefetch-after-scheduled", { visibleLoad })
+    if (previewAfterTimer) {
+      debug.log("preview:prefetch-after:skip", { reason: "timer-already-set", visibleLoad, pendingVisibleLoad: pendingPreviewAfterVisible, state: previewScrollState() })
+      return
+    }
+    debug.log("preview:prefetch-after-scheduled", { visibleLoad, state: previewScrollState() })
     previewAfterTimer = setTimeout(() => {
       const pendingVisibleLoad = pendingPreviewAfterVisible
       previewAfterTimer = undefined
@@ -573,18 +674,19 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
       const scroll = previewScroll
       const children = scroll?.getChildren()
       if (!scroll || !children || children.length === 0) return
-      const lastChild = children[children.length - 1] as { y: number; height: number }
-      const totalContentHeight = lastChild.y + lastChild.height
-      const atTop = scroll.y <= 0
+      const totalContentHeight = scroll.scrollHeight
+      const atTop = scroll.scrollTop <= 0
       const prefetchDistance = Math.max(2, Math.floor(scroll.height * PREVIEW_PREFETCH_VIEWPORTS))
-      const nearTop = scroll.y <= prefetchDistance
-      const atBottom = scroll.y + scroll.height >= totalContentHeight - 1
-      const nearBottom = scroll.y + scroll.height >= totalContentHeight - prefetchDistance
+      const nearTop = scroll.scrollTop <= prefetchDistance
+      const atBottom = scroll.scrollTop + scroll.height >= totalContentHeight - 1
+      const nearBottom = scroll.scrollTop + scroll.height >= totalContentHeight - prefetchDistance
       if (nearTop || nearBottom) {
         debug.log("preview:scroll-edge", {
           y: scroll.y,
+          scrollTop: scroll.scrollTop,
           height: scroll.height,
           contentHeight: totalContentHeight,
+          childContentHeight: previewScrollState().childContentHeight,
           prefetchDistance,
           atTop,
           nearTop,
@@ -597,7 +699,7 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
           children: children.length,
         })
       }
-      if (atTop && hasMorePreviewBefore()) schedulePreviewBefore(totalContentHeight, false, true)
+      if (atTop && hasMorePreviewBefore()) schedulePreviewBefore(totalContentHeight, true, false)
       if (nearBottom && hasMorePreviewAfter()) schedulePreviewAfter(atBottom)
     }, 400)
     onCleanup(() => clearInterval(interval))
@@ -625,7 +727,31 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
 
   const scrollPreview = (direction: 1 | -1, evt: ParsedKey) => {
     prevent(evt)
-    previewScroll?.scrollBy(direction * previewScrollAmount(previewScroll))
+    const scroll = previewScroll
+    if (!scroll) {
+      debug.log("preview:scroll-key:skip", { reason: "no-scroll", direction })
+      return
+    }
+
+    const beforeState = previewScrollState()
+    debug.log("preview:scroll-key", { direction, state: beforeState })
+
+    if (direction < 0 && scroll.scrollTop <= 0 && hasMorePreviewBefore()) {
+      debug.log("preview:scroll-key:load-before", { direction, state: beforeState })
+      schedulePreviewBefore(previewContentHeight(), true, true)
+      return
+    }
+
+    const totalContentHeight = scroll.scrollHeight
+    if (direction > 0 && scroll.scrollTop + scroll.height >= totalContentHeight - 1 && hasMorePreviewAfter()) {
+      debug.log("preview:scroll-key:load-after", { direction, totalContentHeight, state: beforeState })
+      schedulePreviewAfter(true)
+      return
+    }
+
+    const amount = direction * previewScrollAmount(scroll)
+    scroll.scrollBy(amount)
+    debug.log("preview:scroll-key:scroll", { direction, amount, before: beforeState, after: previewScrollState() })
   }
 
   const focusInput = () => {

package/ui/render-target.ts

@@ -1,20 +1,48 @@
 import type { ScrollBoxRenderable } from "@opentui/core"
 import type { SearchResult } from "../search.ts"
+import { debug } from "./debug.ts"
 
 export function previewScrollAmount(scroll: ScrollBoxRenderable | undefined) {
   return Math.max(1, Math.floor((scroll?.height || 10) / 8))
 }
 
 export function messageTargetID(item: SearchResult) {
+  if (item.partType === "tool") return `tool-${item.messageID}-${item.id}`
+  if (item.partType === "reasoning") return `text-${item.messageID}-${item.id}`
   if (item.role === "assistant") return `text-${item.messageID}-${item.id}`
   return item.messageID
 }
 
 export function scrollPreviewToTarget(scroll: ScrollBoxRenderable | undefined, targetID: string) {
-  if (!scroll) return
+  if (!scroll) {
+    debug.log("preview:target-scroll:skip", { reason: "no-scroll", targetID })
+    return
+  }
   const target = findRenderableByID(scroll, targetID)
-  if (!target) return
-  scroll.scrollBy(target.y - scroll.y - Math.max(1, Math.floor(scroll.height / 3)))
+  if (!target) {
+    debug.log("preview:target-scroll:skip", {
+      reason: "target-not-found",
+      targetID,
+      y: scroll.y,
+      scrollTop: scroll.scrollTop,
+      scrollHeight: scroll.scrollHeight,
+      height: scroll.height,
+      children: scroll.getChildren().length,
+    })
+    return
+  }
+  const delta = target.y - scroll.y - Math.max(1, Math.floor(scroll.height / 3))
+  debug.log("preview:target-scroll", {
+    targetID,
+    targetY: target.y,
+    scrollY: scroll.y,
+    scrollTop: scroll.scrollTop,
+    scrollHeight: scroll.height,
+    contentHeight: scroll.scrollHeight,
+    delta,
+  })
+  scroll.scrollBy(delta)
+  debug.log("preview:target-scroll:after", { targetID, scrollY: scroll.y, scrollTop: scroll.scrollTop })
 }
 
 export function jumpToRenderedTarget(root: unknown, targetID: string) {