opencode-vim 0.0.7 → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-vim",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "exports": {
     "./tui": {
       "import": "./tui.tsx"

package/src/modules/vim/actions.ts

@@ -1,3 +1,4 @@
+import type { RGBA } from "@opentui/core"
 import type { TuiPromptInfo, TuiPromptRef } from "@opencode-ai/plugin/tui"
 import type { PromptContext } from "../../prompt/types"
 import type { VimCursorStyle } from "./config"
@@ -6,12 +7,17 @@ export type EditBufferLike = {
     cursorOffset?: number
     plainText?: string
     visualCursor?: VisualCursorLike
-    editorView?: { getVisualEOL?: () => VisualCursorLike | undefined }
+    editorView?: { getVisualEOL?: () => VisualCursorLike | undefined; setSelection?: (start: number, end: number, bgColor?: RGBA, fgColor?: RGBA) => void; resetSelection?: () => void }
     cursorStyle?: VimCursorStyle
+    selectionBg?: RGBA
+    selectionFg?: RGBA
     moveCursorLeft?: () => boolean
     moveCursorRight?: () => boolean
     moveCursorUp?: () => boolean
     moveCursorDown?: () => boolean
+    setSelection?: (start: number, end: number) => void
+    setSelectionInclusive?: (start: number, end: number) => void
+    clearSelection?: () => void
     gotoVisualLineEnd?: () => boolean
     gotoLineEnd?: () => void
 }

package/src/modules/vim/config.ts

@@ -31,6 +31,8 @@ export type VimMappedAction = string
 const DEFAULT_CURSOR_STYLES: Record<VimMode, VimCursorStyle> = {
     insert: { style: "line", blinking: true },
     normal: { style: "block", blinking: true },
+    visual: { style: "block", blinking: true },
+    "visual-line": { style: "block", blinking: true },
 }
 
 export function createVimConfig(options: unknown): VimConfig {
@@ -42,6 +44,8 @@ export function createVimConfig(options: unknown): VimConfig {
         cursorStyles: {
             insert: { ...DEFAULT_CURSOR_STYLES.insert, ...input.cursorStyles?.insert },
             normal: { ...DEFAULT_CURSOR_STYLES.normal, ...input.cursorStyles?.normal },
+            visual: { ...DEFAULT_CURSOR_STYLES.visual, ...input.cursorStyles?.visual },
+            "visual-line": { ...DEFAULT_CURSOR_STYLES["visual-line"], ...input.cursorStyles?.["visual-line"] },
         },
         debug: input.debug ?? process.env.VIM_PROMPT_DEBUG === "1",
         debugPath: input.debugPath,
@@ -71,7 +75,7 @@ function readKeymaps(input: unknown): VimKeymaps | undefined {
     const source = input as Record<string, unknown>
     const keymaps: VimKeymaps = {}
 
-    for (const mode of ["insert", "normal"] as const) {
+    for (const mode of ["insert", "normal", "visual", "visual-line"] as const) {
         const raw = source[mode]
         if (!raw || typeof raw !== "object") continue
         keymaps[mode] = {}
@@ -89,6 +93,8 @@ function readCursorStyles(input: unknown): VimOptions["cursorStyles"] {
     return {
         insert: readCursorStyle(source.insert),
         normal: readCursorStyle(source.normal),
+        visual: readCursorStyle(source.visual),
+        "visual-line": readCursorStyle(source["visual-line"]),
     }
 }
 
@@ -107,7 +113,7 @@ function isCursorStyle(value: unknown): value is VimCursorStyle["style"] {
 }
 
 function isMode(value: unknown): value is VimMode {
-    return value === "insert" || value === "normal"
+    return value === "insert" || value === "normal" || value === "visual" || value === "visual-line"
 }
 
 function isMappedAction(value: unknown): value is VimMappedAction {

package/src/modules/vim/map.ts

@@ -15,12 +15,13 @@ export function createPromptMap(hostText: string, input?: EditBufferLike): Promp
 export function derivePromptMap(map: PromptMap, vimText: string): PromptMap {
     const prefix = commonPrefix(map.vimText, vimText)
     const suffix = commonSuffix(map.vimText, vimText, prefix)
+    const inserted = vimText.slice(prefix, vimText.length - suffix)
     const synthetic = new Set<number>()
     let hostText = ""
 
     for (let vimOffset = 0; vimOffset < vimText.length; vimOffset++) {
         const oldOffset = previousOffset(map, vimOffset, vimText.length, prefix, suffix)
-        if (oldOffset !== undefined && map.vimToHost[oldOffset] === undefined) {
+        if (oldOffset !== undefined && map.vimToHost[oldOffset] === undefined && preserveSynthetic(vimOffset, prefix, suffix, vimText.length, inserted)) {
             synthetic.add(vimOffset)
             continue
         }
@@ -31,6 +32,11 @@ export function derivePromptMap(map: PromptMap, vimText: string): PromptMap {
     return buildPromptMapFromSynthetic(hostText, vimText, synthetic)
 }
 
+function preserveSynthetic(vimOffset: number, prefix: number, suffix: number, vimLength: number, inserted: string) {
+    if (!inserted.includes("\n")) return true
+    return vimOffset !== prefix - 1 && vimOffset !== vimLength - suffix
+}
+
 export function hostPosition(map: PromptMap, hostOffset: number): CursorPosition {
     return positionFromOffset(map.vimText, map.hostToVim[clamp(hostOffset, 0, map.hostText.length)] ?? 0)
 }

package/src/modules/vim/state.ts

@@ -1,7 +1,7 @@
 import { createSignal } from "solid-js"
 import type { VimLog } from "./log"
 
-export type VimMode = "normal" | "insert"
+export type VimMode = "normal" | "insert" | "visual" | "visual-line"
 
 export function createVimState(defaultMode: VimMode, log: VimLog = () => {}) {
     const [mode, setMode] = createSignal<VimMode>(defaultMode)

package/src/modules/vim/view.tsx

@@ -45,7 +45,7 @@ export function VimStatus(props: VimStatusProps) {
     return (
         <box paddingLeft={1} paddingRight={1} flexDirection="row">
             {pending() ? <text fg={props.theme.info}>{pending()} </text> : undefined}
-            <text fg={props.disabled ? props.theme.textMuted : mode() === "normal" ? props.theme.warning : props.theme.success}>{mode() === "normal" ? "NORMAL" : "INSERT"}</text>
+            <text fg={props.disabled ? props.theme.textMuted : mode() === "insert" ? props.theme.success : props.theme.warning}>{modeLabel(mode())}</text>
         </box>
     )
 
@@ -84,3 +84,9 @@ export function VimStatus(props: VimStatusProps) {
         props.requestRender?.()
     }
 }
+
+function modeLabel(mode: VimMode) {
+    if (mode === "visual") return "VISUAL"
+    if (mode === "visual-line") return "VISUAL LINE"
+    return mode === "normal" ? "NORMAL" : "INSERT"
+}

package/src/modules/vim/vimee.ts

@@ -10,6 +10,9 @@ import type { createVimState } from "./state"
 
 type VimState = ReturnType<typeof createVimState>
 type HostAction = VimeeAction | { type: "submit" }
+type HostRange = { start: number; end: number }
+
+const YANK_FLASH_MS = 250
 
 export type VimeeAdapter = ReturnType<typeof createVimeeAdapter>
 
@@ -20,6 +23,8 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
     let vim = createInitialContext({ line: 0, col: 0 })
     const keybinds = createKeybinds(config, log)
     let timer: ReturnType<typeof setTimeout> | undefined
+    let yankTimer: ReturnType<typeof setTimeout> | undefined
+    let yankFlashActive = false
     let pendingInsert = ""
     let nativeInsertUndoSaved = false
 
@@ -62,9 +67,24 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
                 return true
             }
 
+            const hostEnd = vimeeKey === "e" ? endMotionOffset(map.hostText, offset, vim.count || 1) : undefined
+            const shouldFlashYank = shouldFlashYankFor(vimeeKey)
+            const visualYankRange = visualYankRangeFor(map)
             const result = processKeystroke(vimeeKey, vim, buffer, event.ctrl, false, keybinds)
             vim = result.newCtx
-            applyActions(result.actions as HostAction[], ctx, map)
+            if (hostEnd !== undefined && result.actions.every((action) => action.type === "cursor-move") && hostEnd > hostOffset(map, vim.cursor, "previous")) vim = { ...vim, cursor: hostPosition(map, hostEnd) }
+            let clampFinalCursor = true
+            const content = result.actions.find((action) => action.type === "content-change")?.content
+            if (vimeeKey === "x" && content !== undefined) {
+                const next = nextMap(map, content)
+                const target = clamp(offset, 0, Math.max(0, next.hostText.length - 1))
+                if (offset < map.hostText.length - 1 && map.hostText[offset + 1] !== "\n" && hostOffset(next, vim.cursor, "previous") < target) {
+                    vim = { ...vim, cursor: hostPosition(next, target) }
+                    clampFinalCursor = false
+                }
+            }
+            applyActions(result.actions as HostAction[], ctx, map, clampFinalCursor)
+            if (shouldFlashYank) flashYank(ctx, activeMap, yankAction(result.actions), visualYankRange)
             syncMode(state, vim.mode)
             const keybindPending = keybinds?.isPending() ?? false
             if (wasPending && !keybindPending && pendingBefore && state.mode() === "insert") flushPendingInsert(ctx, pendingBefore, offset)
@@ -76,6 +96,7 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
         },
         cleanup() {
             if (timer) clearTimeout(timer)
+            if (yankTimer) clearTimeout(yankTimer)
         },
     }
 
@@ -113,7 +134,7 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
         return next
     }
 
-    function applyActions(actions: HostAction[], ctx: PromptContext, map: PromptMap) {
+    function applyActions(actions: HostAction[], ctx: PromptContext, map: PromptMap, clampFinalCursor = true) {
         const ref = ctx.prompt()
         const input = focusedInput(ctx)
         let currentMap = map
@@ -144,7 +165,8 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
             }
         }
 
-        setCursor(input, currentMap, vim.cursor)
+        setCursor(input, currentMap, vim.cursor, clampFinalCursor)
+        syncVisualSelection(input, currentMap, ctx)
     }
 
     function handleInsertMode(event: KeyEvent, key: string, ctx: PromptContext, map: PromptMap, cursor: CursorPosition, offset: number) {
@@ -253,20 +275,190 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
         return hostOffset(map, position, vim.mode === "insert" ? "next" : "previous")
     }
 
-    function setCursor(input: EditBufferLike | undefined, map: PromptMap, position: CursorPosition) {
+    function setCursor(input: EditBufferLike | undefined, map: PromptMap, position: CursorPosition, clampCursor = true) {
         if (!input) return
         input.cursorOffset = cursorOffset(map, position)
-        if (vim.mode !== "insert") clampNormalCursor(input)
+        if (clampCursor && vim.mode !== "insert") clampNormalCursor(input)
     }
 
     function appendVisualLine(input: EditBufferLike | undefined, map: PromptMap) {
         if (!input?.gotoVisualLineEnd) return false
+        clearVisualSelection(input)
         input.gotoVisualLineEnd()
         vim = { ...vim, cursor: hostPosition(map, input.cursorOffset ?? map.hostText.length), mode: "insert", phase: "idle", count: 0, operator: null, statusMessage: "-- INSERT --" }
         nativeInsertUndoSaved = false
         syncMode(state, "insert")
         return true
     }
+
+    function syncVisualSelection(input: EditBufferLike | undefined, map: PromptMap, ctx: PromptContext) {
+        if (!input) return
+        if (!isVisualMode(vim.mode) || !vim.visualAnchor) {
+            if (!yankFlashActive) clearVisualSelection(input)
+            return
+        }
+
+        cancelYankFlash()
+        const range = vim.mode === "visual-line" ? visualLineRange(map, vim.visualAnchor, vim.cursor) : visualCharRange(map, vim.visualAnchor, vim.cursor)
+        if (!range) {
+            clearVisualSelection(input)
+            return
+        }
+
+        setSelection(input, range.start, range.end, ctx)
+    }
+
+    function visualYankRangeFor(map: PromptMap) {
+        if (!isVisualMode(vim.mode) || !vim.visualAnchor) return undefined
+        return vim.mode === "visual-line" ? visualLineRange(map, vim.visualAnchor, vim.cursor) : visualCharRange(map, vim.visualAnchor, vim.cursor)
+    }
+
+    function flashYank(ctx: PromptContext, map: PromptMap, action: YankAction | undefined, visualRange: HostRange | undefined) {
+        if (!action) return
+        const input = focusedInput(ctx)
+        if (!input) return
+        const range = visualRange ?? yankedTextRange(map, vim.cursor, action.text)
+        if (!range) return
+
+        cancelYankFlash()
+        yankFlashActive = true
+        setYankSelection(input, range.start, range.end, ctx)
+        ctx.requestRender()
+        yankTimer = setTimeout(() => {
+            yankTimer = undefined
+            if (!yankFlashActive) return
+            yankFlashActive = false
+            clearVisualSelection(input)
+            ctx.requestRender()
+        }, YANK_FLASH_MS)
+    }
+
+    function cancelYankFlash() {
+        if (yankTimer) clearTimeout(yankTimer)
+        yankTimer = undefined
+        yankFlashActive = false
+    }
+
+    function shouldFlashYankFor(key: string) {
+        if (isVisualMode(vim.mode)) return key === "y"
+        return vim.operator === "y"
+    }
+}
+
+function visualCharRange(map: PromptMap, anchor: CursorPosition, cursor: CursorPosition): HostRange | undefined {
+    const anchorOffset = hostOffset(map, anchor, "next")
+    const cursorOffset = hostOffset(map, cursor, "previous")
+    return hostRange(map, anchorOffset, cursorOffset)
+}
+
+function visualLineRange(map: PromptMap, anchor: CursorPosition, cursor: CursorPosition): HostRange | undefined {
+    const startLine = Math.min(anchor.line, cursor.line)
+    const endLine = Math.max(anchor.line, cursor.line)
+    const start = hostOffset(map, { line: startLine, col: 0 }, "next")
+    const end = hostOffset(map, { line: endLine, col: vimLineLength(map.vimText, endLine) }, "previous")
+    return hostRange(map, start, end)
+}
+
+function yankedTextRange(map: PromptMap, cursor: CursorPosition, text: string): HostRange | undefined {
+    if (!text) return undefined
+    if (text.endsWith("\n")) {
+        const lineCount = text.split("\n").length - 1
+        return visualLineRange(map, cursor, { line: cursor.line + Math.max(0, lineCount - 1), col: 0 })
+    }
+
+    const start = vimOffsetFromPosition(map.vimText, cursor)
+    return vimOffsetRange(map, start, start + text.length - 1)
+}
+
+function vimOffsetRange(map: PromptMap, left: number, right: number): HostRange | undefined {
+    const start = hostFromVimOffset(map, Math.min(left, right), "next")
+    const end = hostFromVimOffset(map, Math.max(left, right), "previous")
+    return hostRange(map, start, end)
+}
+
+function hostRange(map: PromptMap, left: number, right: number): HostRange | undefined {
+    if (!map.hostText) return undefined
+    const start = clamp(Math.min(left, right), 0, Math.max(0, map.hostText.length - 1))
+    const end = clamp(Math.max(left, right), 0, Math.max(0, map.hostText.length - 1))
+    return { start, end }
+}
+
+type YankAction = Extract<VimeeAction, { type: "yank" }>
+
+function yankAction(actions: VimeeAction[]): YankAction | undefined {
+    return actions.find((action): action is YankAction => action.type === "yank")
+}
+
+function setSelection(input: EditBufferLike, start: number, end: number, ctx: PromptContext) {
+    setSelectionColors(input, start, end, ctx.api.theme.current.warning, ctx.api.theme.current.background)
+}
+
+function setYankSelection(input: EditBufferLike, start: number, end: number, ctx: PromptContext) {
+    setSelectionColors(input, start, end, ctx.api.theme.current.info, ctx.api.theme.current.background)
+}
+
+function setSelectionColors(input: EditBufferLike, start: number, end: number, background: PromptContext["api"]["theme"]["current"]["warning"], foreground: PromptContext["api"]["theme"]["current"]["background"]) {
+    input.selectionBg = background
+    input.selectionFg = foreground
+
+    if (input.setSelectionInclusive) {
+        input.setSelectionInclusive(start, end)
+        return
+    }
+
+    const exclusiveEnd = end + 1
+    if (input.setSelection) {
+        input.setSelection(start, exclusiveEnd)
+        return
+    }
+
+    input.editorView?.setSelection?.(start, exclusiveEnd, background, foreground)
+}
+
+function clearVisualSelection(input: EditBufferLike) {
+    if (input.clearSelection) {
+        input.clearSelection()
+        return
+    }
+
+    input.editorView?.resetSelection?.()
+}
+
+function isVisualMode(mode: VimContext["mode"]): mode is "visual" | "visual-line" {
+    return mode === "visual" || mode === "visual-line"
+}
+
+function vimLineLength(text: string, line: number) {
+    return text.split("\n")[line]?.length ?? 0
+}
+
+function vimOffsetFromPosition(text: string, position: CursorPosition) {
+    const lines = text.split("\n")
+    const line = clamp(position.line, 0, Math.max(0, lines.length - 1))
+    let offset = 0
+    for (let index = 0; index < line; index++) offset += lines[index].length + 1
+    return offset + clamp(position.col, 0, lines[line]?.length ?? 0)
+}
+
+function hostFromVimOffset(map: PromptMap, offset: number, bias: "previous" | "next") {
+    const current = clamp(offset, 0, map.vimText.length)
+    if (current === map.vimText.length) return map.hostText.length
+
+    const host = map.vimToHost[current]
+    if (host !== undefined) return host
+
+    if (bias === "previous") {
+        for (let previous = current - 1; previous >= 0; previous--) {
+            const previousHost = map.vimToHost[previous]
+            if (previousHost !== undefined) return previousHost
+        }
+    }
+
+    for (let next = current + 1; next < map.vimToHost.length; next++) {
+        const nextHost = map.vimToHost[next]
+        if (nextHost !== undefined) return nextHost
+    }
+    return map.hostText.length
 }
 
 function clampNormalCursor(input: EditBufferLike) {
@@ -278,6 +470,27 @@ function clampNormalCursor(input: EditBufferLike) {
     if (cursor.visualRow === eol.visualRow && (cursor.offset === eol.offset || offset === eol.offset)) input.cursorOffset = Math.max(0, offset - 1)
 }
 
+function endMotionOffset(text: string, offset: number, count: number) {
+    let index = offset
+    for (let step = 0; step < count; step++) {
+        index++
+        while (index < text.length && isWhitespace(text[index])) index++
+        const kind = wordKind(text[index])
+        if (!kind) return Math.max(0, text.length - 1)
+        while (wordKind(text[index + 1]) === kind) index++
+    }
+    return clamp(index, 0, Math.max(0, text.length - 1))
+}
+
+function isWhitespace(value: string | undefined) {
+    return value === " " || value === "\t" || value === "\n"
+}
+
+function wordKind(value: string | undefined) {
+    if (!value || isWhitespace(value)) return undefined
+    return /\w/.test(value) ? "word" : "punctuation"
+}
+
 function createKeybinds(config: VimConfig, log: VimLog): KeybindMap | undefined {
     const map = createKeybindMap()
     let count = 0
@@ -338,7 +551,7 @@ function tokenCtrl(token: string) {
 }
 
 function syncMode(state: VimState, mode: VimContext["mode"]) {
-    state.setMode(mode === "insert" ? "insert" : "normal")
+    state.setMode(mode === "insert" || mode === "visual" || mode === "visual-line" ? mode : "normal")
 }
 
 function pendingDisplay(ctx: VimContext, keybindPending: boolean) {