opencode-vim 0.0.23 → 0.0.24

package/src/plugin.tsx

@@ -1,116 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui"
-import { createSignal } from "solid-js"
-import { PromptRoot } from "./prompt/root"
-import type { PromptModule } from "./prompt/types"
-import { createVimModule } from "./modules/vim"
-import { createSnippetsModule } from "./modules/snippets"
-import type { SnippetController } from "./modules/snippets/types"
-import { checkAutoUpdate } from "./update"
-
-const tui: TuiPlugin = async (api, options, meta) => {
-    const vimEnabledKey = `${meta.id}:enabled`
-    const [vimEnabled, setVimEnabled] = createSignal(api.kv.get(vimEnabledKey, true) === true)
-
-    api.keymap.registerLayer({
-        commands: [
-            {
-                namespace: "palette",
-                name: "opencode-vim.toggle",
-                title: "Toggle Vim Mode",
-                desc: "Enable or disable Vim key handling",
-                category: "Vim",
-                slashName: "vim",
-                run() {
-                    const next = !vimEnabled()
-                    setVimEnabled(next)
-                    api.kv.set(vimEnabledKey, next)
-                    api.ui.toast({ variant: "info", message: `Vim mode ${next ? "enabled" : "disabled"}` })
-                },
-            },
-        ],
-    })
-
-    if (readAutoUpdate(options)) {
-        let timer: Timer | undefined
-        api.lifecycle.onDispose(() => {
-            if (timer) clearTimeout(timer)
-        })
-
-        void checkAutoUpdate(meta, api.lifecycle.signal).then((result) => {
-            if (!result.updated) return
-
-            timer = setTimeout(() => {
-                api.ui.toast({ variant: "info", message: "Updating opencode-vim. Restart OpenCode to finish." })
-            }, 5000)
-        }).catch(() => {})
-    }
-
-    const moduleCache = new Map<string, PromptModule[]>()
-    const createModules = (key: string) => {
-        const cached = moduleCache.get(key)
-        if (cached) return cached
-
-        const modules: PromptModule[] = []
-        const snippets: SnippetController = {}
-        if (hasSnippetsPlugin(api)) modules.push(createSnippetsModule(snippets))
-        modules.push(createVimModule(options, vimEnabled, snippets))
-        moduleCache.set(key, modules)
-        return modules
-    }
-
-    api.slots.register({
-        order: 50,
-        slots: {
-            home_prompt(ctx, props) {
-                return <PromptRoot api={api} slot={ctx} kind="home" workspaceID={props.workspace_id} ref={props.ref} modules={createModules(`home:${props.workspace_id ?? ""}`)} />
-            },
-            session_prompt(ctx, props) {
-                return (
-                    <PromptRoot
-                        api={api}
-                        slot={ctx}
-                        kind="session"
-                        sessionID={props.session_id}
-                        visible={props.visible}
-                        disabled={props.disabled}
-                        onSubmit={props.on_submit}
-                        ref={props.ref}
-                        modules={createModules(`session:${props.session_id}`)}
-                    />
-                )
-            },
-        },
-    })
-}
-
-function readAutoUpdate(options: unknown) {
-    if (!options || typeof options !== "object") return true
-    const value = (options as { autoUpdate?: unknown }).autoUpdate
-    return typeof value === "boolean" ? value : true
-}
-
-function hasSnippetsPlugin(api: TuiPluginApi) {
-    return configHasSnippets(api.state.config.plugin) || configHasSnippets(api.tuiConfig.plugin) || api.plugins.list().some(pluginHasSnippets)
-}
-
-function configHasSnippets(plugins: unknown) {
-    if (!Array.isArray(plugins)) return false
-    return plugins.some((plugin) => specHasSnippets(Array.isArray(plugin) ? plugin[0] : plugin))
-}
-
-function pluginHasSnippets(plugin: ReturnType<TuiPluginApi["plugins"]["list"]>[number]) {
-    return plugin.enabled && (specHasSnippets(plugin.id) || specHasSnippets(plugin.spec))
-}
-
-function specHasSnippets(spec: unknown) {
-    if (typeof spec !== "string") return false
-    return spec === "opencode-snippets" || spec.startsWith("opencode-snippets@") || spec.includes("/opencode-snippets")
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-    id: "local.opencode-vim",
-    tui,
-}
-
-export default plugin

package/src/prompt/host.tsx

@@ -1,38 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import type { TuiPromptRef } from "@opencode-ai/plugin/tui"
-import type { JSX } from "@opentui/solid"
-import type { PromptContext, PromptModule } from "./types"
-import { submitModules } from "./modules"
-
-type HostPromptProps = {
-    ctx: PromptContext
-    modules: PromptModule[]
-    ref?: (ref: TuiPromptRef | undefined) => void
-    right?: JSX.Element
-}
-
-export function HostPrompt(props: HostPromptProps) {
-    const api = props.ctx.api
-
-    const setRef = (ref: TuiPromptRef | undefined) => {
-        props.ctx.setPromptRef(ref)
-        props.ref?.(ref)
-    }
-
-    const onSubmit = () => {
-        if (submitModules(props.modules, props.ctx)) return
-        props.ctx.submitHost()
-    }
-
-    return (
-        <api.ui.Prompt
-            sessionID={props.ctx.sessionID}
-            workspaceID={props.ctx.workspaceID}
-            visible={props.ctx.visible}
-            disabled={props.ctx.disabled}
-            onSubmit={onSubmit}
-            ref={setRef}
-            right={props.right}
-        />
-    )
-}

package/src/prompt/modules.ts

@@ -1,16 +0,0 @@
-import type { PromptContext, PromptModule } from "./types"
-
-export function sortModules(modules: PromptModule[]) {
-    return [...modules].sort((left, right) => (left.order ?? 0) - (right.order ?? 0) || left.id.localeCompare(right.id))
-}
-
-export function submitModules(modules: PromptModule[], ctx: PromptContext) {
-    for (const module of modules) {
-        if (module.onSubmit?.(ctx) === true) return true
-    }
-    return false
-}
-
-export function notifyPromptRef(modules: PromptModule[], ref: ReturnType<PromptContext["prompt"]>, ctx: PromptContext) {
-    for (const module of modules) module.onPromptRef?.(ref, ctx)
-}

package/src/prompt/root.tsx

@@ -1,69 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { onCleanup } from "solid-js"
-import type { JSX } from "@opentui/solid"
-import { HostPrompt } from "./host"
-import { notifyPromptRef, sortModules } from "./modules"
-import type { PromptContext, PromptRootProps } from "./types"
-
-export function PromptRoot(props: PromptRootProps) {
-    const modules = sortModules(props.modules)
-    const api = props.api
-    let current: ReturnType<PromptContext["prompt"]>
-    const ctx: PromptContext = {
-        api,
-        slot: props.slot,
-        kind: props.kind,
-        get sessionID() {
-            return props.sessionID
-        },
-        get workspaceID() {
-            return props.workspaceID
-        },
-        get visible() {
-            return props.visible
-        },
-        get disabled() {
-            return props.disabled
-        },
-        prompt: () => current,
-        setPromptRef(ref) {
-            current = ref
-            notifyPromptRef(modules, ref, ctx)
-        },
-        submitHost: () => props.onSubmit?.(),
-        requestRender: () => api.renderer.requestRender(),
-    }
-
-    const cleanups = modules.flatMap((module) => {
-        const cleanup = module.setup?.(ctx)
-        return typeof cleanup === "function" ? [cleanup] : []
-    })
-    onCleanup(() => {
-        for (const cleanup of cleanups) cleanup()
-    })
-
-    const moduleAbove = modules.map((module) => module.renderAbove?.(ctx)).filter(Boolean) as JSX.Element[]
-    const moduleBelow = modules.map((module) => module.renderBelow?.(ctx)).filter(Boolean) as JSX.Element[]
-    const moduleRight = modules.map((module) => module.renderRight?.(ctx)).filter(Boolean) as JSX.Element[]
-    const hostRight = renderHostRight(props)
-
-    return (
-        <box>
-            {moduleAbove}
-            <HostPrompt ctx={ctx} modules={modules} ref={props.ref} right={<RightItems items={[...moduleRight, hostRight]} />} />
-            {moduleBelow}
-        </box>
-    )
-}
-
-function renderHostRight(props: PromptRootProps) {
-    const Slot = props.api.ui.Slot
-    if (props.kind === "home") return <Slot name="home_prompt_right" workspace_id={props.workspaceID} />
-    return <Slot name="session_prompt_right" session_id={props.sessionID ?? ""} />
-}
-
-function RightItems(props: { items: JSX.Element[] }) {
-    const items = props.items.filter(Boolean)
-    if (items.length === 0) return undefined
-    return <box flexDirection="row">{items}</box>
-}

package/src/prompt/types.ts

@@ -1,42 +0,0 @@
-import type { JSX } from "@opentui/solid"
-import type { TuiPluginApi, TuiPromptRef, TuiSlotContext } from "@opencode-ai/plugin/tui"
-
-export type PromptKind = "home" | "session"
-
-export type PromptContext = {
-    api: TuiPluginApi
-    slot: TuiSlotContext
-    kind: PromptKind
-    sessionID?: string
-    workspaceID?: string
-    visible?: boolean
-    disabled?: boolean
-    prompt: () => TuiPromptRef | undefined
-    setPromptRef: (ref: TuiPromptRef | undefined) => void
-    submitHost: () => void
-    requestRender: () => void
-}
-
-export type PromptModule = {
-    id: string
-    order?: number
-    setup?: (ctx: PromptContext) => void | (() => void)
-    onPromptRef?: (ref: TuiPromptRef | undefined, ctx: PromptContext) => void
-    onSubmit?: (ctx: PromptContext) => boolean | void
-    renderAbove?: (ctx: PromptContext) => JSX.Element
-    renderBelow?: (ctx: PromptContext) => JSX.Element
-    renderRight?: (ctx: PromptContext) => JSX.Element
-}
-
-export type PromptRootProps = {
-    api: TuiPluginApi
-    slot: TuiSlotContext
-    kind: PromptKind
-    sessionID?: string
-    workspaceID?: string
-    visible?: boolean
-    disabled?: boolean
-    onSubmit?: () => void
-    ref?: (ref: TuiPromptRef | undefined) => void
-    modules: PromptModule[]
-}

package/src/session.tsx

@@ -1,291 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import type { Context } from "@opencode/plugin/tui/context"
-import { type KeyEvent, type TextareaRenderable } from "@opentui/core"
-import { useTerminalDimensions } from "@opentui/solid"
-import { createEffect, createSignal, onCleanup, onMount, untrack } from "solid-js"
-import type { PromptContext } from "./modules/vim/actions"
-import type { VimConfig } from "./modules/vim/config"
-import { keyNotation } from "./modules/vim/keys"
-import { displayWidth } from "./modules/vim/map"
-import { createVimState } from "./modules/vim/state"
-import { createVimeeAdapter, YANK_FLASH_MS } from "./modules/vim/vimee"
-import { createTranscriptSelection } from "./transcript"
-import type { TranscriptItem } from "./transcript-items"
-import type { VimClipboard } from "./clipboard"
-
-export const SESSION_MODE = "opencode-vim.session"
-
-export function createSessionMode(context: Context, config: VimConfig, clipboard: VimClipboard) {
-  const [active, setActive] = createSignal(false)
-  const [reading, setReading] = createSignal<TranscriptItem>()
-  const [notice, setNotice] = createSignal("")
-  const positions = new Map<string, number>()
-  let sessionID = ""
-  let selectedID: string | undefined
-  let prompt: Context["renderer"]["currentFocusedEditor"] = null
-  let transcript: ReturnType<typeof createTranscriptSelection> | undefined
-  let popMode: (() => void) | undefined
-  let prefix = ""
-  let count = ""
-  let disposed = false
-  let noticeTimer: ReturnType<typeof setTimeout> | undefined
-  let yankTimer: ReturnType<typeof setTimeout> | undefined
-  let yankID: string | undefined
-
-  function selected() {
-    return transcript?.get(selectedID)
-  }
-
-  function clearYankFlash() {
-    if (yankTimer) clearTimeout(yankTimer)
-    yankTimer = undefined
-    if (!yankID) return
-    yankID = undefined
-    context.renderer.requestRender()
-  }
-
-  function close() {
-    if (!active()) return
-    clearYankFlash()
-    const wasReading = Boolean(reading())
-    if (wasReading) context.ui.dialog.clear()
-    setActive(false)
-    context.renderer.removePostProcessFn(draw)
-    popMode?.()
-    popMode = undefined
-    transcript = undefined
-    const savedPrompt = prompt
-    const savedSessionID = sessionID
-    function restorePrompt() {
-      const route = context.ui.router.current()
-      if (!active() && context.keymap.mode.current() === "base" && route.type === "session"
-        && route.sessionID === savedSessionID && savedPrompt && !savedPrompt.isDestroyed) savedPrompt.focus()
-    }
-    restorePrompt()
-    // Restore after the dialog's deferred refocus, or it steals focus back.
-    if (wasReading) setTimeout(restorePrompt, 1)
-    prompt = null
-    context.renderer.requestRender()
-  }
-
-  function enter() {
-    const route = context.ui.router.current()
-    if (route.type !== "session") return false
-    sessionID = route.sessionID
-    prompt = context.renderer.currentFocusedEditor
-    prefix = count = ""
-    positions.clear()
-    setNotice("")
-    popMode = context.keymap.mode.push(SESSION_MODE)
-    transcript = createTranscriptSelection(context, sessionID, (id) => {
-      selectedID = id
-    })
-    setActive(true)
-    prompt?.blur()
-    transcript.focus()
-    transcript.latest()
-    context.renderer.addPostProcessFn(draw)
-    context.renderer.requestRender()
-    return true
-  }
-
-  const draw: Parameters<Context["renderer"]["addPostProcessFn"]>[0] = (buffer) => {
-    if (active() && !reading() && context.keymap.mode.current() === SESSION_MODE) transcript?.draw(buffer, yankID)
-  }
-
-  async function copy(text: string) {
-    const copied = await clipboard.write(text)
-    if (disposed) return
-    if (noticeTimer) clearTimeout(noticeTimer)
-    setNotice(copied ? "Copied" : "Yanked · clipboard unavailable")
-    noticeTimer = setTimeout(() => setNotice(""), 1500)
-  }
-
-  function openMessage(message: TranscriptItem) {
-    transcript?.focus()
-    setReading(message)
-    context.ui.dialog.show(() => (
-      <MessageReader context={context} config={config} message={message} offset={positions.get(message.id) ?? 0}
-        copy={copy} notice={notice} remember={(offset) => positions.set(message.id, offset)}
-        back={() => context.ui.dialog.clear()} close={close} />
-    ), () => {
-      setReading(undefined)
-      setNotice("")
-    })
-  }
-
-  const onKey = (event: KeyEvent) => {
-    if (!active() || reading()) return
-    const key = readerKey(context, event, config.sessionKey)
-    if (!key) return
-    event.preventDefault()
-    event.stopPropagation()
-    clearYankFlash()
-    setNotice("")
-    if (key === config.sessionKey || key === "<Esc>" || key === "<C-[>") { close(); return }
-    if (/^[0-9]$/.test(key) && (count || key !== "0")) { count = (count + key).slice(0, 6); return }
-    const amount = Number(count) || 1
-    count = ""
-    const previous = prefix
-    prefix = ""
-    let command = pageCommand(key)
-    if (key === "j" || key === "<Down>") { transcript?.move("next", amount); return }
-    else if (key === "k" || key === "<Up>") { transcript?.move("previous", amount); return }
-    else if (key === "G") { transcript?.latest(); return }
-    else if (key === "g" && previous === "g") command = "session.first"
-    else if (key === "y" && previous === "y") {
-      const message = selected()
-      if (message) {
-        yankID = message.id
-        yankTimer = setTimeout(clearYankFlash, YANK_FLASH_MS)
-        context.renderer.requestRender()
-        void copy(message.text)
-      }
-    } else if (key === "g" || key === "y") prefix = key
-    else if (key === "<CR>") {
-      transcript?.sync()
-      if (transcript?.toggle()) return
-      const message = selected()
-      if (message) openMessage(message)
-    }
-    if (command) {
-      transcript?.followViewport()
-      for (let index = 0; index < amount; index++) context.keymap.dispatch(command)
-    }
-  }
-
-  createEffect(() => {
-    const route = context.ui.router.current()
-    if (active() && (route.type !== "session" || route.sessionID !== sessionID)) untrack(close)
-  })
-  onMount(() => context.renderer.keyInput.prependListener("keypress", onKey))
-  onCleanup(() => {
-    disposed = true
-    close()
-    if (noticeTimer) clearTimeout(noticeTimer)
-    context.renderer.keyInput.off("keypress", onKey)
-  })
-
-  return {
-    active, enter, close,
-    Status() {
-      return <text fg={context.theme.text.feedback.info.base}>
-        {notice() || `SESSION · Enter open · yy copy · ${config.sessionKey} prompt`}
-      </text>
-    },
-  }
-}
-
-function MessageReader(props: {
-  context: Context
-  config: VimConfig
-  message: TranscriptItem
-  offset: number
-  copy: (text: string) => void
-  notice: () => string
-  remember: (offset: number) => void
-  back: () => void
-  close: () => void
-}) {
-  const context = props.context
-  context.ui.dialog.set({ size: "large", centered: true })
-  const dimensions = useTerminalDimensions()
-  const theme = () => context.theme.surface("dialog")
-  const background = () => theme().background.raised.high
-  const state = createVimState("normal")
-  const [line, setLine] = createSignal(1)
-  let input!: TextareaRenderable
-  const adapter = createVimeeAdapter(state, props.config, () => {}, { readOnly: true, onYank: props.copy })
-  const editorContext: PromptContext = {
-    api: {
-      renderer: { get currentFocusedRenderable() { return input } },
-      keymap: { dispatchCommand: () => ({ ok: false }) },
-      theme: { get current() { return {
-        warning: theme().text.feedback.warning.base,
-        info: theme().text.feedback.info.base,
-        background: background(),
-      } } },
-    },
-    prompt: () => ({
-      get current() { return { input: input.plainText, mode: "normal", parts: [] } },
-      set() {}, submit() {}, blur() {},
-    }),
-    requestRender: () => context.renderer.requestRender(),
-  }
-  const onKey = (event: KeyEvent) => {
-    if (context.renderer.currentFocusedEditor !== input) return
-    const key = readerKey(context, event, props.config.sessionKey, "modal")
-    if (!key) return
-    event.preventDefault()
-    event.stopPropagation()
-    if (key === props.config.sessionKey && state.mode() === "normal" && !adapter.isPending()) { props.close(); return }
-    // The host's Ctrl+C clears the editor unless we intercept it.
-    if (key === "<C-c>") { props.back(); return }
-    if ((key === "<Esc>" || key === "<C-[>") && state.mode() === "normal" && !adapter.isPending()) {
-      props.back()
-      return
-    }
-    if (pageCommand(key)) {
-      const down = key === "<C-d>" || key === "<C-f>" || key === "<PageDown>"
-      const half = key === "<C-d>" || key === "<C-u>"
-      const rows = Math.max(1, Math.floor(input.height / (half ? 2 : 1)))
-      for (let row = 0; row < rows; row++) adapter.handle({ ...event, ctrl: false } as KeyEvent, down ? "j" : "k", editorContext)
-    } else adapter.handle(event, key, editorContext)
-    setLine(input.logicalCursor.row + 1)
-  }
-  onMount(() => {
-    input.cursorOffset = Math.min(props.offset, displayWidth(input.plainText))
-    adapter.attach(editorContext)
-    setLine(input.logicalCursor.row + 1)
-    input.focus()
-    context.renderer.keyInput.prependListener("keypress", onKey)
-  })
-  onCleanup(() => {
-    props.remember(input.cursorOffset)
-    context.renderer.keyInput.off("keypress", onKey)
-    adapter.cleanup()
-  })
-
-  function modeLabel() {
-    if (state.mode() === "visual") return "VISUAL"
-    if (state.mode() === "visual-line") return "VISUAL LINE"
-    return "MESSAGE"
-  }
-  return (
-    <box id="vim-message-reader" gap={1}>
-      <box paddingLeft={2} paddingRight={2} flexDirection="row" justifyContent="space-between">
-        <text fg={theme().text.base}><b>{props.message.author}</b></text>
-        <text id="vim-message-close" fg={theme().text.muted} onMouseUp={props.back}>esc</text>
-      </box>
-      <box paddingLeft={2} paddingRight={2} paddingTop={1} paddingBottom={1} backgroundColor={background()}>
-        <textarea id="vim-session-message" ref={(value: TextareaRenderable) => {
-          input = value
-          input.handleKeyPress = () => true
-          input.handlePaste = () => {}
-        }} initialValue={props.message.text} minHeight={1} maxHeight={Math.max(1, Math.min(20, dimensions().height - 10))}
-          wrapMode="word" showCursor cursorStyle={props.config.cursorStyles.normal} textColor={theme().text.base}
-          backgroundColor={background()} focusedBackgroundColor={background()} focusedTextColor={theme().text.base} />
-      </box>
-      <box paddingLeft={2} paddingRight={2} paddingBottom={1} flexDirection="row" flexWrap="wrap" columnGap={3}>
-        <text fg={theme().text.muted}>{modeLabel()} · {line()}/{input?.lineCount ?? 1}</text>
-        <text fg={theme().text.muted}>
-          {props.notice() || (state.mode() !== "normal" ? "y copy · Esc cancel" : `v select · V lines · ${props.config.sessionKey} prompt`)}
-        </text>
-      </box>
-    </box>
-  )
-}
-
-function readerKey(context: Context, event: KeyEvent, sessionKey: string, mode = SESSION_MODE) {
-  if (event.defaultPrevented || context.keymap.mode.current() !== mode) return
-  if (context.keymap.pending().length || event.super || event.meta) return
-  const key = keyNotation(event)
-  if (key && (key === sessionKey || !event.ctrl || key === "<C-[>" || pageCommand(key) || (mode === "modal" && key === "<C-c>"))) return key
-}
-
-function pageCommand(key: string) {
-  if (key === "<C-d>") return "session.half.page.down"
-  if (key === "<C-u>") return "session.half.page.up"
-  if (key === "<C-f>" || key === "<PageDown>") return "session.page.down"
-  if (key === "<C-b>" || key === "<PageUp>") return "session.page.up"
-}