@bojackduy/opencode-telescope 0.1.24 → 0.1.26

package/telescope.tsx

@@ -363,7 +363,7 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
     }
   }
 
-  const loadPreviousResults = (advance = false) => {
+  const loadPreviousResults = async (advance = false) => {
     if (advance) advanceSelectionBeforeLoad = true
     const base = resultBaseOffset()
     if (base <= 0) {
@@ -384,7 +384,7 @@ export const Telescope = (props: { api: TuiPluginApi; config: TelescopeConfig; o
     debug.time("query:load-before")
     try {
       const batch = q
-        ? searchSessionMessages(q, { limit, offset, dbPath: db, directory: dir, role })
+        ? await performSearch(q, { limit, offset, dbPath: db, directory: dir, role })
         : recentSessionMessages({ limit, offset, dbPath: db, directory: dir, role })
       const nextSelected = advanceSelectionBeforeLoad && batch.length > 0 ? base - 1 : selected()
       debug.log("results:load-before", { offset, limit, added: batch.length, fromBase: base, toBase: offset, cached: results().length + batch.length, advance })

package/ui/format.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "bun:test"
+import { compactTime, markdownWithMatch, roleColor, roleLabel, syntaxStyle, toolIcon, toolInputSummary, toolLabel, truncate } from "./format.ts"
+
+describe("format utils", () => {
+  const mockTheme = {
+    info: "#00aaff",
+    primary: "#ff6600",
+    text: "#cccccc",
+    textMuted: "#666666",
+    accent: "#ffffff",
+    background: "#1a1a1a",
+    backgroundPanel: "#222222",
+    backgroundElement: "#2a2a2a",
+    error: "#ff4444",
+    warning: "#ffaa00",
+    success: "#44cc44",
+    markdownHeading: "#ffaa00",
+    markdownStrong: "#ffffff",
+    markdownEmph: "#cccccc",
+    markdownListItem: "#cccccc",
+    markdownBlockQuote: "#888888",
+    markdownCode: "#44aaff",
+    markdownLink: "#44aaff",
+    markdownLinkText: "#ffaa00",
+    markdownText: "#cccccc",
+    syntaxComment: "#6a9955",
+    syntaxString: "#ce9178",
+    syntaxNumber: "#b5cea8",
+    syntaxKeyword: "#569cd6",
+    syntaxType: "#4ec9b0",
+    syntaxFunction: "#dcdcaa",
+    syntaxOperator: "#d4d4d4",
+    syntaxVariable: "#9cdcfe",
+    syntaxPunctuation: "#d4d4d4",
+    diffAdded: "#44cc44",
+    diffRemoved: "#ff4444",
+    diffContext: "#888888",
+    diffAddedBg: "#003300",
+    diffRemovedBg: "#330000",
+    diffContextBg: "#222222",
+    diffHighlightAdded: "#66ff66",
+    diffHighlightRemoved: "#ff6666",
+    diffLineNumber: "#666666",
+    diffAddedLineNumberBg: "#003300",
+    diffRemovedLineNumberBg: "#330000",
+  }
+
+  test("compactTime formats timestamp", () => {
+    const t = new Date("2024-03-15T14:30:00").getTime()
+    const result = compactTime(t)
+    expect(result).toContain("Mar")
+    expect(result).toContain("15")
+    expect(result).toMatch(/(14:30|02:30)/)
+  })
+
+  test("roleLabel returns correct labels", () => {
+    expect(roleLabel("user")).toBe("you")
+    expect(roleLabel("assistant")).toBe("assistant")
+  })
+
+  test("roleColor returns correct colors", () => {
+    expect(roleColor("assistant", mockTheme as never)).toBe(mockTheme.info as never)
+    expect(roleColor("user", mockTheme as never)).toBe(mockTheme.primary as never)
+  })
+
+  test("toolIcon returns correct symbols", () => {
+    expect(toolIcon("bash")).toBe("$")
+    expect(toolIcon("read")).toBe("R")
+    expect(toolIcon("grep")).toBe("G")
+    expect(toolIcon("glob")).toBe("*")
+    expect(toolIcon("write")).toBe("W")
+    expect(toolIcon("edit")).toBe("W")
+    expect(toolIcon("apply_patch")).toBe("W")
+    expect(toolIcon("task")).toBe("T")
+    expect(toolIcon("todowrite")).toBe("☑")
+    expect(toolIcon("webfetch")).toBe("@")
+    expect(toolIcon("websearch")).toBe("@")
+    expect(toolIcon("skill")).toBe("S")
+    expect(toolIcon("question")).toBe("?")
+    expect(toolIcon("unknown")).toBe("⚙")
+    expect(toolIcon(undefined)).toBe("⚙")
+  })
+
+  test("toolLabel returns tool name or default", () => {
+    expect(toolLabel("bash")).toBe("bash")
+    expect(toolLabel(undefined)).toBe("tool")
+  })
+
+  test("toolInputSummary extracts common fields", () => {
+    expect(toolInputSummary({ command: "npm test" })).toBe("npm test")
+    expect(toolInputSummary({ filePath: "src/index.ts" })).toBe("src/index.ts")
+    expect(toolInputSummary({ pattern: "*.ts" })).toBe("*.ts")
+    expect(toolInputSummary({})).toBe("{}")
+    expect(toolInputSummary(null)).toBe("")
+    expect(toolInputSummary("string")).toBe("")
+    expect(toolInputSummary(42)).toBe("")
+    expect(toolInputSummary({ unknown: "x".repeat(200) })).toHaveLength(90)
+  })
+
+  test("markdownWithMatch highlights when match and highlight flag set", () => {
+    expect(markdownWithMatch("before ", "match", " after", true))
+      .toBe("before **match** after")
+    expect(markdownWithMatch("before ", "match", " after", false))
+      .toBe("before match after")
+    expect(markdownWithMatch("text", "", "", true))
+      .toBe("text")
+  })
+
+  test("syntaxStyle returns a SyntaxStyle instance", () => {
+    const style = syntaxStyle(mockTheme as never)
+    expect(style).toBeDefined()
+    expect(typeof style).toBe("object")
+  })
+
+  test("truncate handles short and long strings", () => {
+    expect(truncate("hello", 10)).toBe("hello")
+    expect(truncate("hello world", 8)).toBe("hello w…")
+    expect(truncate("", 5)).toBe("")
+  })
+})

package/ui/preview-utils.test.ts

@@ -0,0 +1,161 @@
+import { describe, expect, test } from "bun:test"
+import { clippedText, containsOrderedTokens, conversationMatch, filetype, matchExcerpt, parseApplyPatchFiles, shortPath } from "./preview-utils.ts"
+
+describe("containsOrderedTokens", () => {
+  test("matches tokens in order", () => {
+    expect(containsOrderedTokens("let me test this", "let me")).toBe(true)
+    expect(containsOrderedTokens("let me test this", "test this")).toBe(true)
+  })
+
+  test("matches with gaps between tokens", () => {
+    expect(containsOrderedTokens("let us now test me please", "let me")).toBe(true)
+  })
+
+  test("rejects out-of-order tokens", () => {
+    expect(containsOrderedTokens("me let", "let me")).toBe(false)
+  })
+
+  test("returns false for empty query", () => {
+    expect(containsOrderedTokens("hello", "")).toBe(false)
+    expect(containsOrderedTokens("hello", "   ")).toBe(false)
+  })
+
+  test("is case insensitive", () => {
+    expect(containsOrderedTokens("HELLO WORLD", "hello world")).toBe(true)
+  })
+})
+
+describe("clippedText", () => {
+  test("returns full text when under threshold", () => {
+    const result = clippedText("short text", "text", 10)
+    expect(result.clipped).toBe(false)
+    expect(result.text).toBe("short text")
+  })
+
+  test("clips large text without match line", () => {
+    const large = "line\n".repeat(500)
+    const result = clippedText(large, "nonexistent", 10)
+    expect(result.clipped).toBe(true)
+    expect(result.text.split("\n").length).toBeLessThan(30)
+  })
+
+  test("clips large text around match line", () => {
+    const lines: string[] = []
+    for (let i = 0; i < 500; i++) lines.push(`line ${i}`)
+    lines[250] = "needle here"
+    const result = clippedText(lines.join("\n"), "needle", 10)
+    expect(result.clipped).toBe(true)
+    expect(result.text).toContain("needle")
+    expect(result.text).toContain("lines omitted")
+  })
+})
+
+describe("matchExcerpt", () => {
+  test("returns snippet around match", () => {
+    const text = "a ".repeat(50) + "needle here" + " b".repeat(50)
+    const result = matchExcerpt(text, "needle")
+    expect(result).toBeDefined()
+    expect(result!.match).toContain("needle")
+    expect(result!.before).toContain("...")
+    expect(result!.after).toContain("...")
+  })
+
+  test("returns undefined for empty query", () => {
+    expect(matchExcerpt("hello", "")).toBeUndefined()
+    expect(matchExcerpt("hello", "   ")).toBeUndefined()
+  })
+
+  test("returns undefined when query not found", () => {
+    expect(matchExcerpt("hello world", "missing")).toBeUndefined()
+  })
+})
+
+describe("conversationMatch", () => {
+  test("finds match in text", () => {
+    const result = conversationMatch("hello world", true, "world")
+    expect(result).toEqual({ start: 6, end: 11 })
+  })
+
+  test("returns undefined when target is false", () => {
+    expect(conversationMatch("hello", false, "hello")).toBeUndefined()
+  })
+
+  test("returns undefined when match is empty", () => {
+    expect(conversationMatch("hello", true, "")).toBeUndefined()
+  })
+
+  test("returns undefined when no match found", () => {
+    expect(conversationMatch("hello", true, "world")).toBeUndefined()
+  })
+})
+
+describe("parseApplyPatchFiles", () => {
+  test("parses valid metadata", () => {
+    const metadata = {
+      files: [
+        { filePath: "/project/src/index.ts", patch: "diff content", type: "update", deletions: 0 },
+      ],
+    }
+    const result = parseApplyPatchFiles(metadata)
+    expect(result).toHaveLength(1)
+    expect(result[0]!.filePath).toBe("/project/src/index.ts")
+    expect(result[0]!.relativePath).toBe("/project/src/index.ts")
+    expect(result[0]!.patch).toBe("diff content")
+  })
+
+  test("returns empty for missing or invalid metadata", () => {
+    expect(parseApplyPatchFiles(null)).toEqual([])
+    expect(parseApplyPatchFiles({})).toEqual([])
+    expect(parseApplyPatchFiles({ files: "not-array" })).toEqual([])
+  })
+
+  test("skips entries with missing required fields", () => {
+    const metadata = {
+      files: [
+        { filePath: "/a.ts", patch: "diff" },
+        { filePath: "/b.ts" },
+        { patch: "diff" },
+      ],
+    }
+    const result = parseApplyPatchFiles(metadata)
+    expect(result).toHaveLength(1)
+    expect(result[0]!.filePath).toBe("/a.ts")
+  })
+})
+
+describe("shortPath", () => {
+  test("returns last 3 segments", () => {
+    expect(shortPath("/project/src/components/Button.tsx")).toBe("src/components/Button.tsx")
+  })
+
+  test("handles short paths", () => {
+    expect(shortPath("file.ts")).toBe("file.ts")
+  })
+
+  test("returns default for empty path", () => {
+    expect(shortPath("")).toBe("file")
+  })
+})
+
+describe("filetype", () => {
+  test("maps known extensions", () => {
+    expect(filetype("file.ts")).toBe("typescript")
+    expect(filetype("file.tsx")).toBe("typescript")
+    expect(filetype("file.py")).toBe("python")
+    expect(filetype("file.go")).toBe("go")
+    expect(filetype("file.rs")).toBe("rust")
+    expect(filetype("file.md")).toBe("markdown")
+    expect(filetype("file.json")).toBe("json")
+    expect(filetype("file.sh")).toBe("shellscript")
+  })
+
+  test("returns 'none' for empty or unknown", () => {
+    expect(filetype("file")).toBe("none")
+    expect(filetype("file.unknown")).toBe("unknown")
+  })
+
+  test("is case insensitive", () => {
+    expect(filetype("file.TS")).toBe("typescript")
+    expect(filetype("file.MD")).toBe("markdown")
+  })
+})

package/ui/preview-utils.ts

@@ -0,0 +1,136 @@
+export 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
+}
+
+export 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
+}
+
+export 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,
+  }
+}
+
+export function matchExcerpt(text: string, query: string, radius = 80) {
+  const needle = query.trim()
+  if (!needle) return
+  const tokens = needle.split(/\s+/)
+  const lowerText = text.toLowerCase()
+  let searchPos = 0
+  let firstStart = -1
+  let lastEnd = -1
+  for (const token of tokens) {
+    const start = lowerText.indexOf(token.toLowerCase(), searchPos)
+    if (start === -1) return
+    if (firstStart === -1) firstStart = start
+    searchPos = start + token.length
+    lastEnd = searchPos
+  }
+  const beforeStart = Math.max(0, firstStart - radius)
+  const afterEnd = Math.min(text.length, lastEnd + radius)
+  return {
+    before: `${beforeStart > 0 ? "..." : ""}${text.slice(beforeStart, firstStart).replace(/\s+/g, " ")}`,
+    match: text.slice(firstStart, lastEnd),
+    after: `${text.slice(lastEnd, afterEnd).replace(/\s+/g, " ")}${afterEnd < text.length ? "..." : ""}`,
+  }
+}
+
+export function conversationMatch(text: string, target: boolean, match: string) {
+  if (!target || !match) return
+  const tokens = match.split(/\s+/)
+  const lowerText = text.toLowerCase()
+  let searchPos = 0
+  let firstStart = -1
+  let lastEnd = -1
+  for (const token of tokens) {
+    const index = lowerText.indexOf(token.toLowerCase(), searchPos)
+    if (index === -1) return
+    if (firstStart === -1) firstStart = index
+    searchPos = index + token.length
+    lastEnd = searchPos
+  }
+  return { start: firstStart, end: lastEnd }
+}
+
+export 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 }]
+  })
+}
+
+export function shortPath(value: string) {
+  if (!value) return "file"
+  const parts = value.split(/[\\/]/)
+  return parts.slice(-3).join("/")
+}
+
+export 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
+}
+
+export function recordValue(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return
+  return value as Record<string, unknown>
+}
+
+export function stringValue(value: unknown) {
+  return typeof value === "string" ? value : undefined
+}
+
+function numberValue(value: unknown) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined
+}

package/ui/render-target.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "bun:test"
+import { findRenderableByID, messageTargetID, previewScrollAmount } from "./render-target.ts"
+import type { SearchResult } from "../search.ts"
+
+describe("render-target utils", () => {
+  test("messageTargetID returns correct IDs", () => {
+    const toolItem = { partType: "tool", messageID: "msg_1", id: "prt_1" } as SearchResult
+    expect(messageTargetID(toolItem)).toBe("tool-msg_1-prt_1")
+
+    const reasoningItem = { partType: "reasoning", messageID: "msg_2", id: "prt_2" } as SearchResult
+    expect(messageTargetID(reasoningItem)).toBe("text-msg_2-prt_2")
+
+    const assistantItem = { partType: "text", role: "assistant", messageID: "msg_3", id: "prt_3" } as SearchResult
+    expect(messageTargetID(assistantItem)).toBe("text-msg_3-prt_3")
+
+    const userItem = { partType: "text", role: "user", messageID: "msg_4", id: "prt_4" } as SearchResult
+    expect(messageTargetID(userItem)).toBe("msg_4")
+  })
+
+  test("previewScrollAmount returns minimum of 1", () => {
+    expect(previewScrollAmount(undefined)).toBe(1)
+    expect(previewScrollAmount({ height: 0 } as never)).toBe(1)
+    expect(previewScrollAmount({ height: 10 } as never)).toBe(1)
+    expect(previewScrollAmount({ height: 24 } as never)).toBe(3)
+  })
+
+  test("findRenderableByID traverses render tree", () => {
+    const tree = {
+      id: "root",
+      y: 0,
+      getChildren() {
+        return [
+          { id: "child1", y: 1, height: 10, getChildren: () => [] },
+          {
+            id: "child2",
+            y: 11,
+            height: 20,
+            getChildren: () => [
+              { id: "target", y: 12, height: 5, getChildren: () => [] },
+            ],
+          },
+        ]
+      },
+    }
+
+    const found = findRenderableByID(tree, "target")
+    expect(found).toBeDefined()
+    expect(found!.id).toBe("target")
+    expect(found!.y).toBe(12)
+
+    expect(findRenderableByID(tree, "nonexistent")).toBeUndefined()
+    expect(findRenderableByID(null, "x")).toBeUndefined()
+    expect(findRenderableByID("string", "x")).toBeUndefined()
+  })
+})