@bojackduy/opencode-telescope 0.1.13 → 0.1.15

package/tui.tsx

@@ -1,6 +1,7 @@
 /** @jsxImportSource @opentui/solid */
 import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui"
 import { Telescope } from "./telescope.tsx"
+import { loadTelescopeConfig } from "./ui/config.ts"
 
 const id = "opencode-telescope"
 
@@ -13,9 +14,10 @@ const enabled = (options: unknown) => {
 const tui: TuiPlugin = async (api: TuiPluginApi, options: unknown) => {
   if (!enabled(options)) return
 
+  const config = loadTelescopeConfig()
   const command = "opencode.telescope.sessions"
   const open = () => {
-    api.ui.dialog.replace(() => <Telescope api={api} onClose={() => api.ui.dialog.clear()} />)
+    api.ui.dialog.replace(() => <Telescope api={api} config={config} onClose={() => api.ui.dialog.clear()} />)
     api.ui.dialog.setSize("xlarge")
   }
 
@@ -30,7 +32,7 @@ const tui: TuiPlugin = async (api: TuiPluginApi, options: unknown) => {
         run: open,
       },
     ],
-    bindings: [{ key: "<leader>f", desc: "Search conversations", group: "Search", cmd: open }],
+    bindings: [{ key: config.openKey, desc: "Search conversations", group: "Search", cmd: open }],
   })
 
   api.lifecycle.onDispose(() => {

package/ui/config.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { defaultTelescopeConfig, loadTelescopeConfig, parseTelescopeConfig, telescopeConfigPath } from "./config.ts"
+
+describe("telescope config", () => {
+  test("uses defaults for missing config", () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "opencode-telescope-config-"))
+    try {
+      expect(loadTelescopeConfig(path.join(dir, "missing.json"))).toEqual(defaultTelescopeConfig)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  test("uses defaults for invalid json", () => {
+    const dir = mkdtempSync(path.join(tmpdir(), "opencode-telescope-config-"))
+    const file = path.join(dir, "config.json")
+    try {
+      writeFileSync(file, "{")
+      expect(loadTelescopeConfig(file)).toEqual(defaultTelescopeConfig)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  test("merges valid partial config and ignores invalid fields", () => {
+    const config = parseTelescopeConfig({
+      openKey: " <leader>s ",
+      keys: {
+        moveDown: ["n", 1, ""],
+        moveUp: [],
+        open: "ctrl+o",
+      },
+    })
+
+    expect(config.openKey).toBe("<leader>s")
+    expect(config.keys.moveDown).toEqual(["n"])
+    expect(config.keys.moveUp).toEqual(defaultTelescopeConfig.keys.moveUp)
+    expect(config.keys.open).toEqual(["ctrl+o"])
+    expect(config.keys.close).toEqual(defaultTelescopeConfig.keys.close)
+  })
+
+  test("resolves config under XDG_CONFIG_HOME", () => {
+    expect(telescopeConfigPath({ XDG_CONFIG_HOME: "/tmp/config" })).toBe("/tmp/config/opencode/opencode-telescope/config.json")
+  })
+})

package/ui/config.ts

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync } from "node:fs"
+import { homedir } from "node:os"
+import path from "node:path"
+
+export type TelescopeKeyAction =
+  | "moveDown"
+  | "moveUp"
+  | "scrollPreviewDown"
+  | "scrollPreviewUp"
+  | "open"
+  | "close"
+  | "insertMode"
+  | "normalMode"
+  | "toggleOwner"
+
+export type TelescopeConfig = {
+  openKey: string
+  keys: Record<TelescopeKeyAction, string[]>
+}
+
+export const defaultTelescopeConfig: TelescopeConfig = {
+  openKey: "<leader>f",
+  keys: {
+    moveDown: ["down", "j"],
+    moveUp: ["up", "k"],
+    scrollPreviewDown: ["d"],
+    scrollPreviewUp: ["u"],
+    open: ["enter", "return"],
+    close: ["q", "escape"],
+    insertMode: ["/"],
+    normalMode: ["ctrl+q"],
+    toggleOwner: ["o"],
+  },
+}
+
+export function telescopeConfigPath(env: NodeJS.ProcessEnv = process.env) {
+  const configHome = env.XDG_CONFIG_HOME || path.join(homedir(), ".config")
+  return path.join(configHome, "opencode", "opencode-telescope", "config.json")
+}
+
+export function loadTelescopeConfig(configPath = telescopeConfigPath()): TelescopeConfig {
+  if (!existsSync(configPath)) return cloneConfig(defaultTelescopeConfig)
+
+  try {
+    return parseTelescopeConfig(JSON.parse(readFileSync(configPath, "utf8")))
+  } catch {
+    return cloneConfig(defaultTelescopeConfig)
+  }
+}
+
+export function parseTelescopeConfig(value: unknown): TelescopeConfig {
+  const config = cloneConfig(defaultTelescopeConfig)
+  if (!isRecord(value)) return config
+
+  if (typeof value.openKey === "string" && value.openKey.trim()) {
+    config.openKey = value.openKey.trim()
+  }
+
+  if (!isRecord(value.keys)) return config
+  for (const action of Object.keys(defaultTelescopeConfig.keys) as TelescopeKeyAction[]) {
+    const parsed = parseKeyList(value.keys[action])
+    if (parsed) config.keys[action] = parsed
+  }
+
+  return config
+}
+
+function parseKeyList(value: unknown) {
+  if (typeof value === "string") {
+    const key = value.trim()
+    return key ? [key] : undefined
+  }
+  if (!Array.isArray(value)) return
+
+  const keys = value
+    .filter((item): item is string => typeof item === "string")
+    .map((item) => item.trim())
+    .filter(Boolean)
+  return keys.length > 0 ? keys : undefined
+}
+
+function cloneConfig(config: TelescopeConfig): TelescopeConfig {
+  return {
+    openKey: config.openKey,
+    keys: Object.fromEntries(
+      Object.entries(config.keys).map(([action, keys]) => [action, [...keys]]),
+    ) as Record<TelescopeKeyAction, string[]>,
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value))
+}

package/ui/keyboard.test.ts

@@ -0,0 +1,40 @@
+import type { ParsedKey } from "@opentui/core"
+import { describe, expect, test } from "bun:test"
+import { inputSafeKeys, keyListLabel, matchesKey } from "./keyboard.ts"
+
+describe("keyboard helpers", () => {
+  test("matches simple key names", () => {
+    expect(matchesKey(key("j"), ["j"])).toBe(true)
+    expect(matchesKey(key("j"), ["k"])).toBe(false)
+  })
+
+  test("matches ctrl modifier strings", () => {
+    expect(matchesKey(key("q", { ctrl: true }), ["ctrl+q"])).toBe(true)
+    expect(matchesKey(key("q"), ["ctrl+q"])).toBe(false)
+  })
+
+  test("labels configured key lists", () => {
+    expect(keyListLabel(["ctrl+q"])).toBe("^q")
+    expect(keyListLabel(["enter", "return"])).toBe("enter/return")
+  })
+
+  test("filters text input unsafe plain character keys", () => {
+    expect(inputSafeKeys(["j", "down", "ctrl+j"])).toEqual(["down", "ctrl+j"])
+  })
+})
+
+function key(name: string, options: Partial<ParsedKey> = {}): ParsedKey {
+  return {
+    name,
+    ctrl: false,
+    meta: false,
+    shift: false,
+    option: false,
+    sequence: name,
+    number: false,
+    raw: name,
+    eventType: "press",
+    source: "raw",
+    ...options,
+  }
+}

package/ui/keyboard.ts

@@ -4,6 +4,40 @@ export function isKey(evt: ParsedKey, ...names: string[]) {
   return names.includes(evt.name)
 }
 
+export function matchesKey(evt: ParsedKey, keys: string[]) {
+  return keys.some((key) => matchesKeyString(evt, key))
+}
+
+export function keyListLabel(keys: string[]) {
+  return keys.map(keyLabel).join("/")
+}
+
+export function inputSafeKeys(keys: string[]) {
+  return keys.filter((key) => key.includes("+") || key.length > 1)
+}
+
+function matchesKeyString(evt: ParsedKey, key: string) {
+  const parts = key.toLowerCase().split("+").map((part) => part.trim()).filter(Boolean)
+  const name = parts.at(-1)
+  if (!name || evt.name.toLowerCase() !== name) return false
+
+  const modifiers = new Set(parts.slice(0, -1))
+  return Boolean(evt.ctrl) === modifiers.has("ctrl") &&
+    Boolean(evt.meta) === modifiers.has("meta") &&
+    Boolean(evt.shift) === modifiers.has("shift") &&
+    Boolean(evt.option) === (modifiers.has("alt") || modifiers.has("option"))
+}
+
+function keyLabel(key: string) {
+  return key.split("+")
+    .map((part) => {
+      const value = part.trim()
+      if (value.toLowerCase() === "ctrl") return "^"
+      return value
+    })
+    .join("")
+}
+
 export function prevent(evt: ParsedKey) {
   const controlled = evt as ParsedKey & {
     preventDefault?: () => void

package/ui/render-target.ts

@@ -6,6 +6,8 @@ export function previewScrollAmount(scroll: ScrollBoxRenderable | undefined) {
 }
 
 export function messageTargetID(item: SearchResult) {
+  if (item.partType === "tool") return `tool-inline-${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
 }