opencode-vim 0.0.21 → 0.0.23

package/tui.tsx

@@ -1,7 +1,7 @@
 /** @jsxImportSource @opentui/solid */
 import { Plugin } from "@opencode/plugin/tui"
-import { InputRenderable, type CursorStyleOptions, type KeyEvent } from "@opentui/core"
-import { createEffect, onCleanup } from "solid-js"
+import { InputRenderable, KeyEvent, PasteEvent, type CursorStyleOptions } from "@opentui/core"
+import { createEffect, createSignal, onCleanup } from "solid-js"
 import { applyVimCursorStyle, focusedInput } from "./src/modules/vim/actions"
 import { createVimConfig } from "./src/modules/vim/config"
 import { editInput } from "./src/modules/vim/edit"
@@ -11,6 +11,8 @@ import { displayToChar } from "./src/modules/vim/map"
 import { createVimState } from "./src/modules/vim/state"
 import { createVimeeAdapter } from "./src/modules/vim/vimee"
 import { VimStatus } from "./view"
+import { SESSION_MODE, createSessionMode } from "./src/session"
+import { createVimClipboard } from "./src/clipboard"
 
 type Context = Parameters<Parameters<typeof Plugin.define>[0]["setup"]>[0]
 
@@ -25,10 +27,13 @@ function VimHost(props: { context: Context }) {
   const config = createVimConfig(props.context.options)
   const normalMappings = Object.keys(config.keymaps.normal ?? {})
   const log = createVimLog(config)
+  const clipboard = createVimClipboard(props.context.renderer)
+  const clipboardOptions = { onYank: (text: string) => { void clipboard.write(text) }, readClipboard: clipboard.read }
   const state = createVimState(config.defaultMode, log)
-  const vimee = createVimeeAdapter(state, config, log)
+  const vimee = createVimeeAdapter(state, config, log, clipboardOptions)
   const dialogState = createVimState(config.defaultMode, log)
-  const dialogVimee = createVimeeAdapter(dialogState, config, log)
+  const dialogVimee = createVimeeAdapter(dialogState, config, log, clipboardOptions)
+  const [dialogFocused, setDialogFocused] = createSignal(false)
   const promptVim = { state, vimee }
   const dialogVim = { state: dialogState, vimee: dialogVimee }
   let dialogInput: typeof props.context.renderer.currentFocusedEditor = null
@@ -38,17 +43,17 @@ function VimHost(props: { context: Context }) {
   let cursorMode = ""
   let cursorInput: typeof props.context.renderer.currentFocusedEditor = null
   let originalCursorStyle: CursorStyleOptions | undefined
+  const session = createSessionMode(props.context, config, clipboard)
+  let pendingKeys: Array<KeyEvent | PasteEvent> | undefined
 
   const removeStatus = props.context.ui.slot({
     prepend: "prompt.footer",
     render: (footer) =>
-      footer.mode === "normal" ? (
+      footer.mode === "normal" ? session.active() && !dialogFocused() ? <session.Status /> : (
         <VimStatus
-          mode={state.mode}
-          pending={() => readablePending(state.pending())}
+          mode={() => dialogFocused() ? dialogState.mode() : state.mode()}
           enabled={enabled}
           theme={compatTheme(props.context)}
-          pendingDisplayDelay={config.pendingDisplayDelay}
         />
       ) : null,
   })
@@ -69,6 +74,8 @@ function VimHost(props: { context: Context }) {
             draft.enabled = next
           })
           if (!next) {
+            pendingKeys = undefined
+            session.close()
             vimee.suspend()
             dialogVimee.suspend()
           }
@@ -81,6 +88,13 @@ function VimHost(props: { context: Context }) {
 
   const onKey = (event: KeyEvent) => {
     if (!enabled() || event.defaultPrevented) return
+    if (pendingKeys) {
+      pendingKeys.push(new KeyEvent(event))
+      event.preventDefault()
+      event.stopPropagation()
+      return
+    }
+    if (props.context.keymap.mode.current() === SESSION_MODE) return
     const kind = inputKind(props.context)
     if (!kind) return
     if (props.context.keymap.pending().length) return
@@ -88,6 +102,13 @@ function VimHost(props: { context: Context }) {
     const key = keyNotation(event as never)
     if (!key) return
     const mapped = normalMappings.some((sequence) => sequence.startsWith(key))
+    if (kind === "prompt" && key === config.sessionKey && !mapped && state.mode() === "normal" && !vimee.isPending()) {
+      if (session.enter()) {
+        event.preventDefault()
+        event.stopPropagation()
+        return
+      }
+    }
     if (passThroughKey(event, key, state.mode(), vimee.isPending(), mapped)) return
     if (key === "<Esc>" && state.mode() === "normal" && !vimee.isPending()) return
 
@@ -110,7 +131,29 @@ function VimHost(props: { context: Context }) {
     const before = state.mode()
     let consumed = false
     try {
-      consumed = vimee.handle(event as never, key, ctx as never)
+      const result = vimee.handle(event as never, key, ctx as never)
+      if (typeof result === "boolean") consumed = result
+      else {
+        consumed = true
+        const queued: Array<KeyEvent | PasteEvent> = []
+        pendingKeys = queued
+        const input = props.context.renderer.currentFocusedEditor
+        void result.then((handled) => {
+          if (pendingKeys !== queued) return
+          pendingKeys = undefined
+          if (!handled) return
+          syncCursor(true)
+          // Replay through the host too: a queued i may be followed by native typing.
+          for (const event of queued) {
+            if (!enabled() || props.context.renderer.currentFocusedEditor !== input) break
+            if (event instanceof PasteEvent) props.context.renderer.keyInput.emit("paste", event)
+            else props.context.renderer.keyInput.emit("keypress", event)
+          }
+        }).catch((error) => {
+          if (pendingKeys === queued) pendingKeys = undefined
+          log("vim.clipboard.paste.error", { error: String(error) })
+        })
+      }
     } finally {
       if (consumed || state.mode() !== before) {
         event.preventDefault()
@@ -121,19 +164,37 @@ function VimHost(props: { context: Context }) {
   }
 
   const onFocus = () => {
+    pendingKeys = undefined
     vimee.suspend()
     dialogVimee.suspend()
     syncCursor()
   }
+  const onPaste = (event: PasteEvent) => {
+    if (!pendingKeys || event.defaultPrevented) return
+    pendingKeys.push(new PasteEvent(event.bytes, event.metadata))
+    event.preventDefault()
+    event.stopPropagation()
+  }
   props.context.renderer.keyInput.prependListener("keypress", onKey)
+  props.context.renderer.keyInput.prependListener("paste", onPaste)
   props.context.renderer.on("focused_editor", onFocus)
   createEffect(() => syncCursor())
+  let route = props.context.ui.router.current()
+  createEffect(() => {
+    const next = props.context.ui.router.current()
+    if (next !== route && pendingKeys) onFocus()
+    route = next
+  })
   onCleanup(() => {
+    pendingKeys = undefined
     removeStatus()
+    session.close()
     props.context.renderer.keyInput.off("keypress", onKey)
+    props.context.renderer.keyInput.off("paste", onPaste)
     props.context.renderer.off("focused_editor", onFocus)
     vimee.cleanup()
     dialogVimee.cleanup()
+    void clipboard.dispose()
     restoreCursor()
   })
 
@@ -142,6 +203,7 @@ function VimHost(props: { context: Context }) {
   function syncCursor(force = false) {
     const input = props.context.renderer.currentFocusedEditor
     const kind = inputKind(props.context)
+    setDialogFocused(kind === "dialog")
     if (!enabled() || !kind || !input) {
       restoreCursor()
       return
@@ -150,7 +212,7 @@ function VimHost(props: { context: Context }) {
     if (kind === "dialog" && dialogInput !== input) {
       dialogInput = input
       dialogVimee.suspend()
-      dialogState.setMode(config.defaultMode)
+      dialogState.setMode(promptVim.state.mode())
     }
     const mode = state.mode()
     vimee.attach(ctx)
@@ -221,6 +283,7 @@ function createCompatContext(context: Context) {
 }
 
 function inputKind(context: Context): "prompt" | "dialog" | undefined {
+  if (context.keymap.mode.current() === SESSION_MODE) return
   if (!context.renderer.currentFocusedEditor) return
   const commands = context.keymap.commands()
   if (context.keymap.mode.current() === "modal") {
@@ -275,7 +338,3 @@ function isCompletionToken(context: Context) {
 function isArrowKey(key: string) {
   return key === "<Left>" || key === "<Down>" || key === "<Up>" || key === "<Right>"
 }
-
-function readablePending(sequence: string) {
-  return sequence ? sequence.replaceAll("><", " ") : undefined
-}

package/view.tsx

@@ -1,37 +1,20 @@
 /** @jsxImportSource @opentui/solid */
 import type { TextRenderable } from "@opentui/core"
-import { createEffect, createSignal, onCleanup, type Accessor } from "solid-js"
+import type { Accessor } from "solid-js"
 import type { VimMode } from "./src/modules/vim/state"
 
 type VimStatusProps = {
   mode: Accessor<VimMode>
-  pending: Accessor<string | undefined>
   enabled: Accessor<boolean>
   theme: {
-    info: TextRenderable["fg"]
     success: TextRenderable["fg"]
     warning: TextRenderable["fg"]
-    textMuted: TextRenderable["fg"]
   }
-  pendingDisplayDelay?: number
 }
 
 export function VimStatus(props: VimStatusProps) {
-  const [pending, setPending] = createSignal<string>()
-  createEffect(() => {
-    const value = props.enabled() ? props.pending() : undefined
-    const delay = props.pendingDisplayDelay ?? 120
-    if (!value || delay <= 0) {
-      setPending(value)
-      return
-    }
-    const timer = setTimeout(() => setPending(value), delay)
-    onCleanup(() => clearTimeout(timer))
-  })
-
   return (
-    <box paddingRight={1} flexDirection="row">
-      <text fg={props.theme.info}>{props.enabled() && pending() ? `${pending()} ` : ""}</text>
+    <box paddingRight={1} flexDirection="row" flexShrink={0}>
       <text fg={props.mode() === "insert" ? props.theme.success : props.theme.warning}>
         {props.enabled() ? modeLabel(props.mode()) : ""}
       </text>