opencode-vim 0.0.23 → 0.0.24

package/src/transcript-items.tsx

@@ -1,168 +0,0 @@
-// Mirrors OpenCode's routes/session/{rows,group-view,anchor-view}.tsx.
-// TSX keeps OpenTUI classes shared with the host under the runtime loader.
-import type { Context } from "@opencode/plugin/tui/context"
-import { MarkdownRenderable, TextBufferRenderable, type Renderable } from "@opentui/core"
-
-type Message = ReturnType<Context["data"]["session"]["message"]["list"]>[number]
-type GroupKind = "reasoning" | "exploration" | "activity" | "instructions"
-export type TranscriptItem = { id: string; author: string; text: string }
-export type TranscriptRange = TranscriptItem & {
-  node: Renderable
-  top: number
-  bottom: number
-  toggle?: Renderable
-  parentID?: string
-}
-
-type Part = TranscriptItem & { messageID: string; kind: string; group?: GroupKind }
-
-function parts(messages: Message[]) {
-  const result: Part[] = []
-  for (const message of messages) {
-    if (message.type === "assistant") {
-      const ordinal = { text: 0, reasoning: 0 }
-      for (const part of message.content) {
-        const partID = part.type === "tool" ? part.id : `${part.type}:${ordinal[part.type]++}`
-        let text = part.type === "tool" ? "" : part.text
-        if (part.type === "reasoning") text = text.replace("[REDACTED]", "")
-        if (part.type !== "tool" && !text.trim()) continue
-        result.push({ id: `session-part:${message.id}:${partID}`, messageID: message.id, kind: part.type,
-          author: part.type === "text" ? "Assistant" : part.type === "reasoning" ? "Reasoning" : part.name,
-          text,
-          group: part.type === "reasoning" ? "reasoning"
-            : part.type === "tool" && ["read", "glob", "grep", "webfetch", "websearch"].includes(part.name.toLowerCase())
-              ? "exploration" : undefined })
-      }
-      // Turn footers prevent groups from spanning into the next assistant turn.
-      if ((message.finish && message.finish !== "tool-calls" && message.finish !== "unknown") || message.error || message.retry) {
-        result.push({ id: `footer:${message.id}`, messageID: message.id, kind: "footer", author: "", text: "" })
-      }
-    } else {
-      result.push({ id: message.id, messageID: message.id, kind: "message", author: message.type === "user" ? "You" : message.type,
-        text: message.type === "user" ? message.text : "" })
-    }
-  }
-  return result
-}
-
-function textOf(node: Renderable): string {
-  if (!node.visible) return ""
-  if (node instanceof MarkdownRenderable) return node.content
-  if (node instanceof TextBufferRenderable) return node.plainText
-  let text = ""
-  let previous: Renderable | undefined
-  for (const child of node.getChildren()) {
-    const value = textOf(child)
-    if (!value) continue
-    if (text) text += previous?.y === child.y ? " " : "\n"
-    text += value
-    previous = child
-  }
-  return text
-}
-
-export function groupAt(node: Renderable) {
-  const header = node.getChildren()[0]
-  if (!header) return
-  const body = header.getChildren()[0]
-  let label: string
-  if (body instanceof TextBufferRenderable) {
-    if (!body.plainText.startsWith("⋯ ")) return
-    label = body.plainText.slice(2).trim()
-  } else {
-    const cells = body?.getChildren() ?? []
-    if (cells.length < 2 || !cells.slice(1).every((cell) => cell instanceof TextBufferRenderable)) return
-    label = cells.slice(1).map((cell) => (cell as TextBufferRenderable).plainText).join(" ").trim()
-  }
-  let kind: GroupKind
-  if (/^(Thought|Thinking)(?:$|[: ·…])/.test(label)) kind = "reasoning"
-  else if (/^Explor(?:ed|ing):/.test(label)) kind = "exploration"
-  else if (/^Instructions:/.test(label)) kind = "instructions"
-  else if (/^(?:\d+ (?:commands?|edits?|thoughts?|reads?|tools?|instructions?)(?:, |$))+$/.test(label)
-    || /^(?:Running|Preparing) .+…$/.test(label)) kind = "activity"
-  else return
-  return { header, kind, label, children: node.getChildren().slice(1) }
-}
-
-export function transcriptItems(rows: Renderable[], messages: Message[]) {
-  const sources = parts(messages)
-  const ranges: TranscriptRange[] = []
-  let cursor = 0
-  let lastSource = -1
-
-  function add(node: Renderable, source?: Part, parentID?: string) {
-    const text = source?.text || textOf(node)
-    if (!text.trim()) return
-    ranges.push({ id: source?.id ?? node.id, author: source?.author ?? "Tool", text, node,
-      top: node.y, bottom: node.y + node.height, parentID })
-  }
-
-  function group(node: Renderable, parentID?: string): boolean {
-    const info = groupAt(node)
-    if (!info) return false
-    const id = node.id
-    ranges.push({ id, author: info.label, text: info.label, node: info.header,
-      top: info.header.y, bottom: info.header.y + info.header.height, toggle: info.header, parentID })
-    let children = info.children
-    // Only exploration groups have EntryAnchors directly under GroupAnchor.
-    if (info.kind !== "exploration" && children.length) {
-      children = [...children[0].getChildren(), ...children.slice(1)]
-    }
-    for (const child of children) {
-      if (!child.visible || !child.height) continue
-      if (!group(child, id)) add(child, undefined, id)
-    }
-    return true
-  }
-
-  for (const row of rows) {
-    if (row.id === "session-navigation-slack") break
-    if (!row.visible || !row.height) continue
-    const anchor = row.getChildren()[0]
-    const info = anchor && groupAt(anchor)
-    // Groups can consume a message's first parts without claiming its row ID.
-    let index = sources.findIndex((part) => part.id === row.id)
-    if (index === -1) {
-      index = sources.findIndex((part, position) => position >= cursor && part.messageID === row.id)
-      if (index !== -1 && !info) {
-        const text = textOf(row).trim()
-        const match = sources.findIndex((part, position) => position >= cursor && part.messageID === row.id && part.text.trim() === text)
-        if (text && match !== -1) index = match
-      }
-    }
-    if (index !== -1) cursor = index
-    if (!info && index === -1 && sources[cursor]?.kind === "footer") {
-      lastSource = cursor++
-      continue
-    }
-    const container = anchor && !(anchor instanceof TextBufferRenderable) && !(anchor instanceof MarkdownRenderable)
-    if (index === -1 && !info && sources[cursor]?.group && container) index = cursor
-    if (anchor && info) {
-      group(anchor)
-      // Track grouped sources to detect newer cached rows that aren't mounted yet.
-      while (cursor < sources.length) {
-        const part = sources[cursor]
-        if (info.kind === "activity" ? part.kind !== "tool" && part.kind !== "reasoning" : part.group !== info.kind) break
-        lastSource = cursor++
-      }
-    } else if (index !== -1) {
-      const source = sources[index]
-      if (source.kind === "footer") {
-        lastSource = cursor++
-      } else if (source.group && container && anchor.getChildren().length) {
-        // With grouping disabled, the GroupAnchor holds individual EntryAnchors.
-        for (const child of anchor.getChildren()) {
-          add(child, sources[cursor])
-          cursor++
-        }
-        lastSource = cursor - 1
-      } else {
-        add(row, source)
-        lastSource = cursor++
-      }
-    }
-  }
-  let last = sources.length - 1
-  while (last >= 0 && (sources[last].kind === "message" || sources[last].kind === "footer") && !sources[last].text) last--
-  return { ranges, hasLatest: lastSource >= last }
-}

package/src/transcript.tsx

@@ -1,179 +0,0 @@
-// TSX ensures the plugin loader shares the host's OpenTUI classes.
-import type { Context } from "@opencode/plugin/tui/context"
-import { MouseEvent, ScrollBoxRenderable, type OptimizedBuffer, type Renderable } from "@opentui/core"
-import { groupAt, transcriptItems, type TranscriptRange } from "./transcript-items"
-
-export function createTranscriptSelection(context: Context, sessionID: string, select: (id: string | undefined) => void) {
-  let scroll: ScrollBoxRenderable | undefined
-  let requestedID: string | undefined
-  let selectedParents: string[] = []
-  let navigation: {
-    from: string | undefined
-    offset: number
-    latest?: boolean
-    loading?: { key: string; frame: number; up: boolean; height: number }
-  } | undefined
-
-  function choose(range: TranscriptRange, view: NonNullable<ReturnType<typeof inspect>>) {
-    requestedID = range.id
-    select(requestedID)
-    let delta = 0
-    if (range.bottom <= view.top) delta = range.top - view.top
-    else if (range.top >= view.bottom) {
-      delta = range.top - view.top - Math.max(0, view.bottom - view.top - (range.bottom - range.top))
-    }
-    if (delta) {
-      const slack = view.scroll.getRenderable("session-navigation-slack")?.height ?? 0
-      const maximum = Math.max(0, view.scroll.scrollHeight - slack - view.scroll.viewport.height)
-      const position = Math.max(0, Math.min(maximum, view.scroll.scrollTop + delta))
-      if (slack) context.keymap.dispatch(delta < 0 ? "session.line.up" : "session.line.down")
-      view.scroll.scrollTo(position)
-    }
-    context.renderer.requestRender()
-  }
-
-  function advance() {
-    if (!navigation) return
-    const view = inspect()
-    const ranges = view?.ranges ?? []
-    const from = navigation.from ? ranges.findIndex((range) => range.id === navigation!.from) : ranges.length
-    if (navigation.from && from === -1) { navigation = undefined; return }
-    const target = navigation.latest ? ranges.length - 1 : from + navigation.offset
-    const loading = navigation.loading
-    // OpenCode compensates for prepended rows after two animation frames.
-    if (loading && context.renderer.frameId < loading.frame) {
-      context.renderer.requestRender()
-      return
-    }
-    if (view && loading?.up && view.scroll.scrollHeight > loading.height) {
-      const maximum = Math.max(0, view.scroll.scrollHeight - view.scroll.viewport.height)
-      const compensated = Math.max(0, Math.min(maximum, view.scroll.scrollHeight - loading.height - 1))
-      if (view.scroll.scrollTop < compensated) return
-    }
-    if (view && target >= 0 && target < ranges.length && (!navigation.latest || view.hasLatest)) {
-      navigation = undefined
-      choose(ranges[target], view)
-      return
-    }
-    const up = !navigation.latest && target < 0
-    const messages = context.data.session.message.list(sessionID)
-    const key = `${messages[0]?.id}:${messages.length}:${ranges[0]?.id}:${ranges.at(-1)?.id}:${view?.scroll.scrollHeight}`
-    if (loading?.key === key) return
-    navigation.loading = { key, frame: context.renderer.frameId + 2, up, height: view?.scroll.scrollHeight ?? 0 }
-    view?.scroll.scrollTo(up ? 0 : view.scroll.scrollHeight)
-    context.keymap.dispatch(up ? "session.line.up" : "session.line.down")
-    context.renderer.requestRender()
-  }
-
-  function latest() {
-    if (!context.data.session.message.list(sessionID).length) {
-      navigation = undefined
-      requestedID = undefined
-      select(undefined)
-      return
-    }
-    navigation = { from: undefined, offset: 0, latest: true }
-    advance()
-  }
-
-  function move(direction: "next" | "previous", count: number) {
-    if (navigation && (navigation.latest || (navigation.offset < 0 && direction === "next") || (navigation.offset > 0 && direction === "previous"))) {
-      navigation = undefined
-    }
-    navigation ??= { from: requestedID ?? inspect()?.selected?.id, offset: 0 }
-    navigation.offset += direction === "next" ? count : -count
-    if (navigation.loading) navigation.loading.key = ""
-    advance()
-  }
-
-  function inspect() {
-    const messages = context.data.session.message.list(sessionID)
-    const ids = new Set(messages.map((message) => message.id))
-    function isRow(node: Renderable) {
-      if (ids.has(node.id) || (node.id?.startsWith("session-part:") && ids.has(node.id.split(":")[1]))) return true
-      const anchor = node.getChildren()[0]
-      return Boolean(anchor && groupAt(anchor))
-    }
-    function findScroll(node: Renderable): ScrollBoxRenderable | undefined {
-      if (!node.visible) return
-      if (node instanceof ScrollBoxRenderable && node.getChildren().some(isRow)) return node
-      for (const child of node.getChildren()) {
-        const found = findScroll(child)
-        if (found) return found
-      }
-    }
-    if (!scroll || scroll.isDestroyed) scroll = findScroll(context.renderer.root)
-    if (!scroll) { select(undefined); return }
-    const { ranges, hasLatest } = transcriptItems(scroll.getChildren(), messages)
-    const top = scroll.viewport.y
-    const bottom = top + scroll.viewport.height
-    let selected = ranges.find((range) => range.id === requestedID)
-    if (!selected && requestedID) {
-      for (const id of selectedParents) {
-        selected = ranges.find((range) => range.id === id)
-        if (selected) { requestedID = id; break }
-      }
-      if (!selected) requestedID = undefined
-    }
-    selected ??= ranges.find((range) => range.top <= top + 1 && range.bottom > top + 1)
-      ?? ranges.find((range) => range.bottom > top && range.top < bottom)
-    selectedParents = []
-    let parent = selected?.parentID
-    while (parent) {
-      selectedParents.push(parent)
-      parent = ranges.find((range) => range.id === parent)?.parentID
-    }
-    select(selected?.id)
-    return { scroll, selected, ranges, hasLatest, top, bottom }
-  }
-
-  return {
-    latest, move,
-    get(id: string | undefined) {
-      if (!scroll || scroll.isDestroyed) return
-      return transcriptItems(scroll.getChildren(), context.data.session.message.list(sessionID)).ranges.find((range) => range.id === id)
-    },
-    toggle() {
-      const range = inspect()?.selected
-      if (!range?.toggle) return false
-      navigation = undefined
-      requestedID = range.id
-      const node = range.toggle
-      node.processMouseEvent(new MouseEvent(node, { type: "up", button: 0, x: node.x, y: node.y,
-        modifiers: { shift: false, alt: false, ctrl: false } }))
-      context.renderer.requestRender()
-      return true
-    },
-    followViewport() { navigation = undefined; requestedID = undefined; selectedParents = [] },
-    focus() { inspect()?.scroll.focus() },
-    sync() { advance(); navigation = undefined; return inspect() },
-    draw(buffer: OptimizedBuffer, yankID?: string) {
-      advance()
-      const view = inspect()
-      if (!view?.selected) return
-      const top = Math.max(0, view.top, view.selected.top)
-      const bottom = Math.min(buffer.height, view.bottom, view.selected.bottom)
-      if (view.selected.id === yankID) {
-        const node = view.selected.node
-        const left = Math.max(0, view.scroll.viewport.x, node.x)
-        const right = Math.min(buffer.width, view.scroll.viewport.x + view.scroll.viewport.width, node.x + node.width)
-        const foreground = context.theme.background.base.buffer
-        const background = context.theme.text.feedback.info.base.buffer
-        const colors = buffer.buffers
-        // Change only colors to preserve wide-character continuation cells.
-        for (let y = top; y < bottom; y++) {
-          for (let x = left; x < right; x++) {
-            const offset = (y * buffer.width + x) * 4
-            colors.fg.set(foreground, offset)
-            colors.bg.set(background, offset)
-          }
-        }
-      }
-      const x = view.scroll.x - 1
-      if (x < 0) return
-      for (let y = top; y < bottom; y++) {
-        buffer.drawText("▎", x, y, context.theme.text.feedback.info.base, context.theme.background.base)
-      }
-    },
-  }
-}

package/src/update.ts

@@ -1,120 +0,0 @@
-import { rm } from "node:fs/promises"
-import { basename, dirname, join } from "node:path"
-import { fileURLToPath } from "node:url"
-import type { TuiPluginMeta } from "@opencode-ai/plugin/tui"
-
-type PackageJson = {
-    name?: string
-    version?: string
-    dependencies?: Record<string, string>
-}
-
-type UpdateResult =
-    | { updated: true; name: string; current: string; latest: string }
-    | { updated: false; error: "remove_failed"; name: string; current: string; latest: string }
-    | { updated: false }
-
-export async function checkAutoUpdate(meta: TuiPluginMeta, signal: AbortSignal): Promise<UpdateResult> {
-    if (meta.source !== "npm") return { updated: false }
-
-    const packageDir = await findPackageDir()
-    if (!packageDir) return { updated: false }
-
-    const pkg = await readPackageJson(join(packageDir, "package.json"))
-    if (!pkg.name || !pkg.version) return { updated: false }
-
-    const latest = await fetchLatestVersion(pkg.name, signal)
-    if (!latest || !isVersionNewer(latest, pkg.version)) return { updated: false }
-
-    const removeDir = await updateRemoveDir(packageDir, pkg.name)
-    try {
-        await rm(removeDir, { recursive: true, force: true })
-    } catch {
-        return { updated: false, error: "remove_failed", name: pkg.name, current: pkg.version, latest }
-    }
-
-    return { updated: true, name: pkg.name, current: pkg.version, latest }
-}
-
-async function findPackageDir() {
-    let dir = dirname(fileURLToPath(import.meta.url))
-    for (;;) {
-        const packagePath = join(dir, "package.json")
-        const pkg = await readPackageJson(packagePath)
-        if (pkg?.name === "opencode-vim") return dir
-
-        const parent = dirname(dir)
-        if (parent === dir) return undefined
-        dir = parent
-    }
-}
-
-async function updateRemoveDir(packageDir: string, name: string) {
-    const nodeModulesDir = dirname(packageDir)
-    if (basename(nodeModulesDir) !== "node_modules") return packageDir
-
-    const wrapperDir = dirname(nodeModulesDir)
-    const wrapperPkg = await readPackageJson(join(wrapperDir, "package.json"))
-    return wrapperPkg?.dependencies?.[name] ? wrapperDir : packageDir
-}
-
-async function readPackageJson(path: string): Promise<PackageJson | undefined> {
-    try {
-        const file = Bun.file(path)
-        if (!(await file.exists())) return undefined
-        const data = await file.json()
-        return data && typeof data === "object" ? (data as PackageJson) : undefined
-    } catch {
-        return undefined
-    }
-}
-
-async function fetchLatestVersion(name: string, signal: AbortSignal) {
-    try {
-        const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(name)}/latest`, { signal })
-        if (!response.ok) return undefined
-        const data = await response.json()
-        return data && typeof data === "object" && typeof data.version === "string" ? data.version : undefined
-    } catch {
-        return undefined
-    }
-}
-
-function isVersionNewer(latest: string, current: string) {
-    const next = parseVersion(latest)
-    const prev = parseVersion(current)
-    if (!next || !prev) return false
-
-    for (let i = 0; i < 3; i++) {
-        if (next.parts[i] !== prev.parts[i]) return next.parts[i] > prev.parts[i]
-    }
-
-    if (!next.pre.length && prev.pre.length) return true
-    if (next.pre.length && !prev.pre.length) return false
-
-    for (let i = 0; i < Math.max(next.pre.length, prev.pre.length); i++) {
-        const a = next.pre[i]
-        const b = prev.pre[i]
-        if (a === undefined) return false
-        if (b === undefined) return true
-        if (a === b) continue
-
-        const aNumber = /^\d+$/.test(a) ? Number(a) : undefined
-        const bNumber = /^\d+$/.test(b) ? Number(b) : undefined
-        if (aNumber !== undefined && bNumber !== undefined) return aNumber > bNumber
-        if (aNumber !== undefined) return false
-        if (bNumber !== undefined) return true
-        return a > b
-    }
-
-    return false
-}
-
-function parseVersion(version: string) {
-    const match = version.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.+)?$/)
-    if (!match) return undefined
-    return {
-        parts: [Number(match[1]), Number(match[2]), Number(match[3])],
-        pre: match[4]?.split(".") ?? [],
-    }
-}