opencode-vim 0.0.19 → 0.0.21

package/src/modules/vim/index.tsx

@@ -7,6 +7,7 @@ import type { SnippetController } from "../snippets/types"
 import { applyVimCursorStyle, focusedInput } from "./actions"
 import type { VimConfig } from "./config"
 import { createVimConfig } from "./config"
+import { displayToChar } from "./map"
 import { keyNotation } from "./keys"
 import { createVimLog } from "./log"
 import type { VimLog } from "./log"
@@ -38,17 +39,9 @@ export function createVimModule(options?: unknown, enabled: Accessor<boolean> =
 function VimKeyboard(props: { ctx: PromptContext; config: VimConfig; state: ReturnType<typeof createVimState>; snippets?: SnippetController; enabled: Accessor<boolean>; log: VimLog }) {
     let cursorStyleMode = ""
     const vimee = createVimeeAdapter(props.state, props.config, props.log)
-    const preparedEvents = new WeakSet<KeyEvent>()
     props.log("keyboard.mount", { kind: props.ctx.kind })
 
     const cursorStyleTimer = setInterval(syncCursorStyle, 50)
-    const offKeyIntercept = props.ctx.api.keymap.intercept("key", ({ event }) => {
-        if (!canHandleKeys(props)) return
-        const key = keyNotation(event)
-        if (!key || !passThroughKey(event, key, props.state.mode())) return
-        if (preparePassThroughKey(props.ctx, key, props.state.mode())) preparedEvents.add(event)
-    }, { priority: 100 })
-
     const offKeyboard = props.ctx.api.keymap.intercept("key", ({ event }) => {
         props.log("keyboard.event", {
             name: event.name,
@@ -72,10 +65,7 @@ function VimKeyboard(props: { ctx: PromptContext; config: VimConfig; state: Retu
             return
         }
 
-        if (passThroughKey(event, key, props.state.mode())) {
-            if (!preparedEvents.delete(event)) preparePassThroughKey(props.ctx, key, props.state.mode())
-            return
-        }
+        if (passThroughKey(event, key, props.state.mode())) return
 
         if (key === "<Esc>" && props.state.mode() === "normal" && !props.state.pending()) {
             props.log("keyboard.fallthrough", { key, mode: props.state.mode() })
@@ -88,10 +78,17 @@ function VimKeyboard(props: { ctx: PromptContext; config: VimConfig; state: Retu
             return
         }
 
-        const consumed = vimee.handle(event, key, props.ctx)
+        const modeBefore = props.state.mode()
+        let consumed = false
+        try {
+            consumed = vimee.handle(event, key, props.ctx)
+        } finally {
+            if (consumed || props.state.mode() !== modeBefore) {
+                event.preventDefault()
+                event.stopPropagation()
+            }
+        }
         if (consumed) {
-            event.preventDefault()
-            event.stopPropagation()
             syncCursorStyle(true)
             props.ctx.requestRender()
         }
@@ -99,7 +96,6 @@ function VimKeyboard(props: { ctx: PromptContext; config: VimConfig; state: Retu
 
     onCleanup(() => {
         props.log("keyboard.cleanup", { kind: props.ctx.kind })
-        offKeyIntercept()
         offKeyboard()
         vimee.cleanup()
         clearInterval(cursorStyleTimer)
@@ -128,15 +124,7 @@ function readablePending(sequence: string) {
 
 function passThroughKey(event: KeyEvent, key: string, mode: string) {
     if (mode !== "normal") return false
-    return event.super === true || isArrowKey(key) || key === "<CR>" || key === "<C-c>"
-}
-
-function preparePassThroughKey(ctx: PromptContext, key: string, mode: string) {
-    if (mode !== "normal" || key !== "<CR>") return false
-    const input = focusedInput(ctx)
-    if (!input?.plainText || input.cursorOffset === undefined) return false
-    input.cursorOffset = Math.min(input.cursorOffset + 1, input.plainText.length)
-    return true
+    return event.super === true || isArrowKey(key) || key === "<C-c>"
 }
 
 function sendNavigationKey(event: KeyEvent, ctx: PromptContext, key: string, mode: string, snippets?: SnippetController) {
@@ -178,8 +166,8 @@ function isPromptFocused(ctx: PromptContext) {
 function isNativeCompletionToken(ctx: PromptContext) {
     const text = ctx.prompt()?.current.input ?? focusedInput(ctx)?.plainText ?? ""
     const input = focusedInput(ctx)
-    const offset = Math.max(0, input?.cursorOffset ?? text.length)
-    const beforeCursor = text.slice(0, Math.min(offset + 1, text.length))
+    const charIdx = displayToChar(text, Math.max(0, input?.cursorOffset ?? 0))
+    const beforeCursor = text.slice(0, Math.min(charIdx + 1, text.length))
     return /^\/\S*$/.test(beforeCursor) || /(?:^|\s)@\S*$/.test(beforeCursor)
 }
 

package/src/modules/vim/keys.ts

@@ -1,5 +1,7 @@
 import type { KeyEvent } from "@opentui/core"
 
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" })
+
 const NAMED_KEYS: Record<string, string> = {
     escape: "<Esc>",
     esc: "<Esc>",
@@ -15,6 +17,8 @@ const NAMED_KEYS: Record<string, string> = {
     right: "<Right>",
     home: "<Home>",
     end: "<End>",
+    pageup: "<PageUp>",
+    pagedown: "<PageDown>",
 }
 
 export function keyNotation(event: KeyEvent) {
@@ -23,7 +27,7 @@ export function keyNotation(event: KeyEvent) {
 
     if (event.ctrl) return `<C-${ctrlKey(name)}>`
     if (event.meta) return `<M-${name}>`
-    if (name.length === 1) return event.shift ? name.toUpperCase() : name
+    if ([...graphemes.segment(name)].length === 1) return event.shift ? name.toUpperCase() : name
     return NAMED_KEYS[name] ?? `<${name}>`
 }
 

package/src/modules/vim/map.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test"
+import { charToDisplay, displayToChar, displayWidth } from "./map"
+
+describe("vim display offsets", () => {
+    test("maps ASCII and CJK offsets", () => {
+        const text = "a中b"
+
+        expect(displayWidth(text)).toBe(4)
+        expect(charToDisplay(text, 2)).toBe(3)
+        expect(displayToChar(text, 2)).toBe(1)
+        expect(displayToChar(text, 3)).toBe(2)
+    })
+
+    test("does not split supplementary characters", () => {
+        const text = "𠀀x"
+
+        expect(displayWidth(text)).toBe(3)
+        expect(charToDisplay(text, 1)).toBe(0)
+        expect(charToDisplay(text, 2)).toBe(2)
+        expect(displayToChar(text, 1)).toBe(0)
+        expect(displayToChar(text, 2)).toBe(2)
+    })
+
+    test("does not split grapheme clusters", () => {
+        const emoji = "👨‍👩‍👧‍👦"
+        const accent = "e\u0301"
+
+        expect(displayWidth(emoji)).toBe(2)
+        expect(charToDisplay(emoji, 1)).toBe(0)
+        expect(displayToChar(emoji, 1)).toBe(0)
+        expect(displayToChar(emoji, 2)).toBe(emoji.length)
+        expect(displayWidth(accent)).toBe(1)
+        expect(charToDisplay(accent, 1)).toBe(0)
+        expect(displayToChar(accent, 1)).toBe(accent.length)
+    })
+
+    test("counts newlines as textarea offsets", () => {
+        const text = "中\nx"
+
+        expect(displayWidth(text)).toBe(4)
+        expect(displayToChar(text, 2)).toBe(1)
+        expect(displayToChar(text, 3)).toBe(2)
+        expect(charToDisplay(text, 2)).toBe(3)
+    })
+})

package/src/modules/vim/map.ts

@@ -1,15 +1,50 @@
 import type { CursorPosition } from "@vimee/core"
 import type { EditBufferLike } from "./actions"
+import { createGraphemeCodec, type GraphemeCodec } from "./graphemes"
+
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" })
+
+function graphemeWidth(value: string) {
+    // Textarea offsets count newlines as one position; Bun.stringWidth counts them as zero.
+    // OpenTUI's edit buffer gives tabs a fixed two-column width by default.
+    if (value === "\t") return 2
+    return value === "\n" ? 1 : Bun.stringWidth(value)
+}
+
+export function charToDisplay(text: string, charIndex: number): number {
+    let width = 0
+    const limit = Math.max(0, Math.min(charIndex, text.length))
+    for (const part of graphemes.segment(text)) {
+        if (part.index + part.segment.length > limit) break
+        width += graphemeWidth(part.segment)
+    }
+    return width
+}
+
+export function displayToChar(text: string, displayOffset: number): number {
+    let width = 0
+    for (const part of graphemes.segment(text)) {
+        const next = width + graphemeWidth(part.segment)
+        if (next > displayOffset) return part.index
+        width = next
+    }
+    return text.length
+}
+
+export function displayWidth(text: string): number {
+    return charToDisplay(text, text.length)
+}
 
 export type PromptMap = {
+    codec: GraphemeCodec
     hostText: string
     vimText: string
     hostToVim: number[]
     vimToHost: Array<number | undefined>
 }
 
-export function createPromptMap(hostText: string, input?: EditBufferLike): PromptMap {
-    return buildPromptMap(hostText, input ? visualWrapOffsets(input, hostText) : [])
+export function createPromptMap(hostText: string, input?: EditBufferLike, codec = createGraphemeCodec()): PromptMap {
+    return buildPromptMap(hostText, input ? visualWrapOffsets(input, hostText) : [], codec)
 }
 
 export function derivePromptMap(map: PromptMap, vimText: string): PromptMap {
@@ -26,10 +61,10 @@ export function derivePromptMap(map: PromptMap, vimText: string): PromptMap {
             continue
         }
 
-        hostText += vimText[vimOffset]
+        hostText += map.codec.decode(vimText[vimOffset])
     }
 
-    return buildPromptMapFromSynthetic(hostText, vimText, synthetic)
+    return buildPromptMapFromSynthetic(hostText, vimText, synthetic, map.codec)
 }
 
 function preserveSynthetic(vimOffset: number, prefix: number, suffix: number, vimLength: number, inserted: string) {
@@ -37,38 +72,40 @@ function preserveSynthetic(vimOffset: number, prefix: number, suffix: number, vi
     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)
+export function hostPosition(map: PromptMap, hostDisplayOffset: number): CursorPosition {
+    const charIdx = displayToChar(map.hostText, hostDisplayOffset)
+    return positionFromOffset(map.vimText, map.hostToVim[clamp(charIdx, 0, map.hostText.length)] ?? 0)
 }
 
 export function hostOffset(map: PromptMap, position: CursorPosition, bias: "previous" | "next" = "next") {
-    return hostOffsetFromVimOffset(map, offsetFromPosition(map.vimText, position), bias)
+    const charIdx = hostOffsetFromVimOffset(map, offsetFromPosition(map.vimText, position), bias)
+    return charToDisplay(map.hostText, charIdx)
 }
 
-function buildPromptMap(hostText: string, wraps: number[]): PromptMap {
+function buildPromptMap(hostText: string, wraps: number[], codec: GraphemeCodec): PromptMap {
     const hostToVim: number[] = []
     const vimToHost: Array<number | undefined> = []
     const wrapOffsets = new Set(wraps.filter((offset) => offset > 0 && offset < hostText.length && hostText[offset - 1] !== "\n"))
     let vimText = ""
     let vimOffset = 0
 
-    for (let hostOffset = 0; hostOffset < hostText.length; hostOffset++) {
+    for (const { index: hostOffset, segment } of graphemes.segment(hostText)) {
         if (wrapOffsets.has(hostOffset)) {
             vimText += "\n"
             vimToHost[vimOffset] = undefined
             vimOffset++
         }
-        hostToVim[hostOffset] = vimOffset
-        vimText += hostText[hostOffset]
+        for (let index = hostOffset; index < hostOffset + segment.length; index++) hostToVim[index] = vimOffset
+        vimText += codec.encode(segment)
         vimToHost[vimOffset] = hostOffset
         vimOffset++
     }
 
     hostToVim[hostText.length] = vimOffset
-    return { hostText, vimText, hostToVim, vimToHost }
+    return { hostText, vimText, hostToVim, vimToHost, codec }
 }
 
-function buildPromptMapFromSynthetic(hostText: string, vimText: string, synthetic: Set<number>): PromptMap {
+function buildPromptMapFromSynthetic(hostText: string, vimText: string, synthetic: Set<number>, codec: GraphemeCodec): PromptMap {
     const hostToVim: number[] = []
     const vimToHost: Array<number | undefined> = []
     let hostOffset = 0
@@ -79,13 +116,13 @@ function buildPromptMapFromSynthetic(hostText: string, vimText: string, syntheti
             continue
         }
 
-        hostToVim[hostOffset] = vimOffset
         vimToHost[vimOffset] = hostOffset
-        hostOffset++
+        const length = codec.decode(vimText[vimOffset]).length
+        for (let index = 0; index < length; index++) hostToVim[hostOffset++] = vimOffset
     }
 
     hostToVim[hostText.length] = vimText.length
-    return { hostText, vimText, hostToVim, vimToHost }
+    return { hostText, vimText, hostToVim, vimToHost, codec }
 }
 
 function previousOffset(map: PromptMap, vimOffset: number, vimLength: number, prefix: number, suffix: number) {
@@ -95,22 +132,18 @@ function previousOffset(map: PromptMap, vimOffset: number, vimLength: number, pr
 }
 
 function visualWrapOffsets(input: EditBufferLike, text: string) {
-    const original = input.cursorOffset
     const wraps: number[] = []
-    let previousRow: number | undefined
-
-    for (let offset = 0; offset <= text.length; offset++) {
-        input.cursorOffset = offset
-        const row = input.visualCursor?.visualRow
-        if (row === undefined) {
-            wraps.length = 0
-            break
+    const lines = input.editorView?.getLogicalLineInfo?.()
+    if (!lines) return wraps
+    let line = 1
+    let offset = 0
+    for (const part of graphemes.segment(text)) {
+        while (line < lines.lineStartCols.length && lines.lineStartCols[line] <= offset) {
+            if (lines.lineWraps[line] > 0) wraps.push(part.index)
+            line++
         }
-        if (previousRow !== undefined && row > previousRow && text[offset - 1] !== "\n") wraps.push(offset)
-        previousRow = row
+        offset += graphemeWidth(part.segment)
     }
-
-    input.cursorOffset = original
     return wraps
 }
 

package/src/modules/vim/state.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "bun:test"
+import { createVimState } from "./state"
+
+describe("vim state", () => {
+    test("isolates listener errors", () => {
+        const events: string[] = []
+        const state = createVimState("normal", (event) => events.push(event))
+        state.subscribe(() => {
+            throw new Error("stale renderable")
+        })
+        state.subscribe(() => events.push("listener.complete"))
+
+        expect(() => state.setMode("insert")).not.toThrow()
+        expect(state.mode()).toBe("insert")
+        expect(events).toContain("state.listener.error")
+        expect(events).toContain("listener.complete")
+    })
+})

package/src/modules/vim/state.ts

@@ -33,6 +33,12 @@ export function createVimState(defaultMode: VimMode, log: VimLog = () => {}) {
     }
 
     function notify() {
-        for (const listener of listeners) listener()
+        for (const listener of listeners) {
+            try {
+                listener()
+            } catch (error) {
+                log("state.listener.error", { error: error instanceof Error ? error.message : String(error) })
+            }
+        }
     }
 }

package/src/modules/vim/view.tsx

@@ -58,6 +58,8 @@ export function VimStatus(props: VimStatusProps) {
         unsubscribe()
         clearInterval(timer)
         if (pendingTimer) clearTimeout(pendingTimer)
+        modeText = undefined
+        pendingText = undefined
     })
 
     return (

package/src/modules/vim/vimee.test.ts

@@ -0,0 +1,211 @@
+import { describe, expect, test } from "bun:test"
+import type { KeyEvent } from "@opentui/core"
+import type { PromptContext } from "./actions"
+import { createVimConfig } from "./config"
+import type { VimLog } from "./log"
+import { createVimState, type VimMode } from "./state"
+import { createVimeeAdapter } from "./vimee"
+
+describe("vim command keymaps", () => {
+    test("does not restore stale cursor state after a normal command", () => {
+        const fixture = createFixture("normal", "command:test.run")
+        fixture.dispatch = () => {
+            fixture.input.plainText = "updated"
+            fixture.input.cursorOffset = 7
+        }
+
+        expect(fixture.handle()).toBe(true)
+        expect(fixture.commands).toEqual(["test.run"])
+        expect(fixture.input.cursorOffset).toBe(7)
+    })
+
+    test("uses the host history boundary and restores display width", () => {
+        const fixture = createFixture("normal", "command:prompt.history.next", "中")
+        let boundary = -1
+        fixture.dispatch = () => {
+            boundary = fixture.input.cursorOffset
+            fixture.input.plainText = "中中"
+            fixture.input.cursorOffset = 2
+        }
+
+        expect(fixture.handle()).toBe(true)
+        expect(boundary).toBe(1)
+        expect(fixture.input.cursorOffset).toBe(4)
+    })
+
+    test("dispatches commands in insert mode", () => {
+        const fixture = createFixture("insert", "command:test.run")
+
+        expect(fixture.handle()).toBe(true)
+        expect(fixture.commands).toEqual(["test.run"])
+    })
+
+    test("rejects an empty command name", () => {
+        const logs: Array<[string, unknown]> = []
+        createFixture("normal", "command:   ", "", (event, data) => logs.push([event, data]))
+
+        expect(logs.some(([event]) => event === "vimee.keymap.invalid")).toBe(true)
+    })
+})
+
+describe("vim enter keymaps", () => {
+    test("submits unmapped Enter in normal mode without moving the cursor", () => {
+        const fixture = createFixture("normal", undefined, "中")
+        fixture.input.cursorOffset = 2
+
+        expect(fixture.handle("<CR>")).toBe(true)
+        expect(fixture.submissions).toHaveLength(1)
+        expect(fixture.input.cursorOffset).toBe(2)
+    })
+
+    test("passes unmapped Enter through in insert mode", () => {
+        const fixture = createFixture("insert", undefined)
+
+        expect(fixture.handle("<CR>")).toBe(false)
+        expect(fixture.submissions).toHaveLength(0)
+    })
+
+    test("does not submit a matched mapping with no immediate actions", () => {
+        const fixture = createFixture("normal", "d", "text", () => {}, "<CR>")
+
+        expect(fixture.handle("<CR>")).toBe(true)
+        expect(fixture.submissions).toHaveLength(0)
+    })
+
+    test("runs an Enter command mapping", () => {
+        const fixture = createFixture("normal", "command:test.run", "", () => {}, "<CR>")
+
+        expect(fixture.handle("<CR>")).toBe(true)
+        expect(fixture.commands).toEqual(["test.run"])
+        expect(fixture.submissions).toHaveLength(0)
+    })
+
+    test("applies mode and submit mappings", () => {
+        const normal = createFixture("normal", "insert", "", () => {}, "<CR>")
+        const insert = createFixture("insert", "submit", "", () => {}, "<CR>")
+
+        expect(normal.handle("<CR>")).toBe(true)
+        expect(normal.handle("a")).toBe(false)
+        expect(insert.handle("<CR>")).toBe(true)
+        expect(insert.submissions).toHaveLength(1)
+    })
+
+    test("allows Enter to finish a multi-key mapping", () => {
+        const fixture = createFixture("normal", "command:test.run", "", () => {}, "g<CR>")
+
+        expect(fixture.handle("g")).toBe(true)
+        expect(fixture.handle("<CR>")).toBe(true)
+        expect(fixture.commands).toEqual(["test.run"])
+        expect(fixture.submissions).toHaveLength(0)
+    })
+
+    test("rejects mappings that defer Enter", () => {
+        const logs: Array<[string, unknown]> = []
+        const fixture = createFixture("normal", "command:test.run", "", (event, data) => logs.push([event, data]), "<CR>x")
+
+        expect(fixture.handle("<CR>")).toBe(true)
+        expect(fixture.submissions).toHaveLength(1)
+        expect(logs.some(([event]) => event === "vimee.keymap.invalid")).toBe(true)
+    })
+})
+
+describe("vim prompt history", () => {
+    test("starts from an empty prompt and continues through history", () => {
+        const fixture = createFixture("normal", undefined, "")
+        const entries = ["newest", "older", ""]
+        fixture.dispatch = (command) => {
+            fixture.input.plainText = entries.shift() ?? ""
+            fixture.input.cursorOffset = command === "prompt.history.previous" ? 0 : fixture.input.plainText.length
+        }
+
+        expect(fixture.handle("k")).toBe(true)
+        expect(fixture.handle("k")).toBe(true)
+        expect(fixture.handle("j")).toBe(true)
+        expect(fixture.commands).toEqual([
+            "prompt.history.previous",
+            "prompt.history.previous",
+            "prompt.history.next",
+        ])
+    })
+
+    test("keeps normal movement for a nonempty prompt", () => {
+        const fixture = createFixture("normal", undefined, "text")
+
+        expect(fixture.handle("k")).toBe(true)
+        expect(fixture.handle("j")).toBe(true)
+        expect(fixture.commands).toEqual([])
+    })
+
+    test("stops history navigation after another normal key", () => {
+        const fixture = createFixture("normal", undefined, "")
+        fixture.dispatch = () => {
+            fixture.input.plainText = "recalled"
+        }
+
+        expect(fixture.handle("k")).toBe(true)
+        expect(fixture.handle("h")).toBe(true)
+        expect(fixture.handle("k")).toBe(true)
+        expect(fixture.commands).toEqual(["prompt.history.previous"])
+    })
+
+    test("prefers configured keymaps", () => {
+        const fixture = createFixture("normal", "command:test.run", "", () => {}, "k")
+
+        expect(fixture.handle()).toBe(true)
+        expect(fixture.commands).toEqual(["test.run"])
+    })
+
+    test("completes a pending keymap before history navigation", () => {
+        const fixture = createFixture("normal", "command:test.run", "", () => {}, "gk")
+
+        expect(fixture.handle("g")).toBe(true)
+        expect(fixture.handle("k")).toBe(true)
+        expect(fixture.commands).toEqual(["test.run"])
+    })
+})
+
+function createFixture(mode: VimMode, action: string | undefined, text = "text", log: VimLog = () => {}, mappedKey = "Q") {
+    const input = {
+        plainText: text,
+        cursorOffset: 0,
+        visualCursor: { visualRow: 0, visualCol: 0, offset: 0 },
+        moveCursorLeft: () => false,
+    }
+    const commands: string[] = []
+    const submissions: true[] = []
+    const prompt = {
+        current: { input: text, mode: "normal", parts: [] },
+        set() {},
+        submit() {
+            submissions.push(true)
+        },
+        blur() {},
+    }
+    const fixture = {
+        input,
+        commands,
+        submissions,
+        dispatch: (_command: string) => {},
+        handle: (key = mappedKey) => adapter.handle({ name: key } as KeyEvent, key, ctx),
+    }
+    const ctx = {
+        api: {
+            renderer: { currentFocusedRenderable: input },
+            keymap: {
+                dispatchCommand(command: string) {
+                    commands.push(command)
+                    fixture.dispatch(command)
+                    return { ok: true as const }
+                },
+            },
+        },
+        prompt: () => prompt,
+        requestRender() {},
+    } as unknown as PromptContext
+    const config = createVimConfig({
+        defaultMode: mode,
+        keymaps: action ? { [mode]: { [mappedKey]: action } } : undefined,
+    })
+    const adapter = createVimeeAdapter(createVimState(mode), config, log)
+    return fixture
+}