opencode-vim 0.0.22 → 0.0.24

package/src/modules/vim/map.ts

@@ -1,198 +0,0 @@
-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, codec = createGraphemeCodec()): PromptMap {
-    return buildPromptMap(hostText, input ? visualWrapOffsets(input, hostText) : [], codec)
-}
-
-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 && preserveSynthetic(vimOffset, prefix, suffix, vimText.length, inserted)) {
-            synthetic.add(vimOffset)
-            continue
-        }
-
-        hostText += map.codec.decode(vimText[vimOffset])
-    }
-
-    return buildPromptMapFromSynthetic(hostText, vimText, synthetic, map.codec)
-}
-
-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, 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") {
-    const charIdx = hostOffsetFromVimOffset(map, offsetFromPosition(map.vimText, position), bias)
-    return charToDisplay(map.hostText, charIdx)
-}
-
-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 (const { index: hostOffset, segment } of graphemes.segment(hostText)) {
-        if (wrapOffsets.has(hostOffset)) {
-            vimText += "\n"
-            vimToHost[vimOffset] = undefined
-            vimOffset++
-        }
-        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, codec }
-}
-
-function buildPromptMapFromSynthetic(hostText: string, vimText: string, synthetic: Set<number>, codec: GraphemeCodec): PromptMap {
-    const hostToVim: number[] = []
-    const vimToHost: Array<number | undefined> = []
-    let hostOffset = 0
-
-    for (let vimOffset = 0; vimOffset < vimText.length; vimOffset++) {
-        if (synthetic.has(vimOffset)) {
-            vimToHost[vimOffset] = undefined
-            continue
-        }
-
-        vimToHost[vimOffset] = 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, codec }
-}
-
-function previousOffset(map: PromptMap, vimOffset: number, vimLength: number, prefix: number, suffix: number) {
-    if (vimOffset < prefix) return vimOffset
-    if (vimOffset >= vimLength - suffix) return map.vimText.length - (vimLength - vimOffset)
-    return undefined
-}
-
-function visualWrapOffsets(input: EditBufferLike, text: string) {
-    const wraps: number[] = []
-    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++
-        }
-        offset += graphemeWidth(part.segment)
-    }
-    return wraps
-}
-
-function hostOffsetFromVimOffset(map: PromptMap, vimOffset: number, bias: "previous" | "next") {
-    const offset = clamp(vimOffset, 0, map.vimText.length)
-    if (offset === map.vimText.length) return map.hostText.length
-
-    const host = map.vimToHost[offset]
-    if (host !== undefined) return host
-
-    if (bias === "previous") {
-        for (let previous = offset - 1; previous >= 0; previous--) {
-            const previousHost = map.vimToHost[previous]
-            if (previousHost !== undefined) return previousHost
-        }
-    }
-
-    for (let next = offset + 1; next < map.vimToHost.length; next++) {
-        const nextHost = map.vimToHost[next]
-        if (nextHost !== undefined) return nextHost
-    }
-    return map.hostText.length
-}
-
-function commonPrefix(left: string, right: string) {
-    let index = 0
-    while (index < left.length && index < right.length && left[index] === right[index]) index++
-    return index
-}
-
-function commonSuffix(left: string, right: string, prefix: number) {
-    let length = 0
-    while (length + prefix < left.length && length + prefix < right.length && left[left.length - length - 1] === right[right.length - length - 1]) length++
-    return length
-}
-
-function positionFromOffset(text: string, offset: number): CursorPosition {
-    const lines = text.slice(0, offset).split("\n")
-    return { line: lines.length - 1, col: lines[lines.length - 1]?.length ?? 0 }
-}
-
-function offsetFromPosition(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 clamp(value: number, min: number, max: number) {
-    return Math.max(min, Math.min(max, value))
-}

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

@@ -1,18 +0,0 @@
-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.tsx

@@ -1,46 +0,0 @@
-// Keep this module as TSX so OpenCode's plugin loader rewrites its Solid import
-// to the host runtime shared by the footer and cursor effects.
-import { createSignal } from "solid-js"
-import type { VimLog } from "./log"
-
-export type VimMode = "normal" | "insert" | "visual" | "visual-line"
-export type VimStateListener = () => void
-
-export function createVimState(defaultMode: VimMode, log: VimLog = () => {}) {
-    const [mode, setMode] = createSignal<VimMode>(defaultMode)
-    const [pending, setPending] = createSignal("")
-    const listeners = new Set<VimStateListener>()
-
-    log("state.init", { mode: defaultMode })
-
-    return {
-        mode,
-        setMode(next: VimMode) {
-            const changed = mode() !== next
-            if (changed) log("state.mode", { from: mode(), to: next })
-            setMode(next)
-            if (changed) notify()
-        },
-        pending,
-        setPending(next: string) {
-            const changed = pending() !== next
-            if (changed) log("state.pending", { from: pending(), to: next })
-            setPending(next)
-            if (changed) notify()
-        },
-        subscribe(listener: VimStateListener) {
-            listeners.add(listener)
-            return () => listeners.delete(listener)
-        },
-    }
-
-    function notify() {
-        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

@@ -1,130 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import type { TextRenderable } from "@opentui/core"
-import { onCleanup } from "solid-js"
-import type { Accessor } from "solid-js"
-import type { PromptContext } from "../../prompt/types"
-import type { VimLog } from "./log"
-import type { VimMode, VimStateListener } from "./state"
-
-const STATUS_SYNC_MS = 50
-
-type VimStatusProps = {
-    mode: Accessor<VimMode>
-    pending: Accessor<string | undefined>
-    subscribe: (listener: VimStateListener) => () => void
-    enabled: Accessor<boolean>
-    theme: PromptContext["api"]["theme"]["current"]
-    pendingDisplayDelay?: number
-    disabled?: boolean
-    log?: VimLog
-    requestRender?: () => void
-}
-
-export function VimStatus(props: VimStatusProps) {
-    let modeText: TextRenderable | undefined
-    let pendingText: TextRenderable | undefined
-    let displayedMode = props.mode()
-    let displayedPending: string | undefined
-    let displayedEnabled = props.enabled()
-    let pendingTimer: ReturnType<typeof setTimeout> | undefined
-    let scheduledPending: string | undefined
-
-    const sync = () => {
-        const nextMode = props.mode()
-        const nextPending = props.pending()
-        let changed = false
-
-        if (displayedMode !== nextMode) {
-            props.log?.("status.sync", { fromMode: displayedMode, toMode: nextMode, fromPending: displayedPending, toPending: displayedPending })
-            displayedMode = nextMode
-            changed = true
-        }
-
-        const nextEnabled = props.enabled()
-        if (displayedEnabled !== nextEnabled) {
-            props.log?.("status.enabled", { from: displayedEnabled, to: nextEnabled })
-            displayedEnabled = nextEnabled
-            changed = true
-        }
-
-        if (changed) updateModeText()
-        syncPending(nextPending)
-        if (changed) props.requestRender?.()
-    }
-
-    const unsubscribe = props.subscribe(sync)
-    const timer = setInterval(sync, STATUS_SYNC_MS)
-    onCleanup(() => {
-        unsubscribe()
-        clearInterval(timer)
-        if (pendingTimer) clearTimeout(pendingTimer)
-        modeText = undefined
-        pendingText = undefined
-    })
-
-    return (
-        <box paddingLeft={1} paddingRight={1} flexDirection="row">
-            <text ref={(ref: TextRenderable) => { pendingText = ref; updatePendingText() }} fg={props.theme.info}>{displayedPending ? `${displayedPending} ` : ""}</text>
-            <text ref={(ref: TextRenderable) => { modeText = ref; updateModeText() }} fg={modeColor(displayedMode, displayedEnabled, props.theme, props.disabled)}>{displayedEnabled ? modeLabel(displayedMode) : ""}</text>
-        </box>
-    )
-
-    function updateModeText() {
-        if (!modeText) return
-        modeText.content = displayedEnabled ? modeLabel(displayedMode) : ""
-        modeText.fg = modeColor(displayedMode, displayedEnabled, props.theme, props.disabled)
-    }
-
-    function updatePendingText() {
-        if (!pendingText) return
-        pendingText.content = displayedEnabled && displayedPending ? `${displayedPending} ` : ""
-    }
-
-    function syncPending(nextPending: string | undefined) {
-        if (!nextPending) {
-            if (pendingTimer) clearTimeout(pendingTimer)
-            pendingTimer = undefined
-            scheduledPending = undefined
-            setDisplayedPending(undefined)
-            return
-        }
-
-        if (displayedPending === nextPending) return
-        if (scheduledPending === nextPending) return
-
-        if (pendingTimer) clearTimeout(pendingTimer)
-        scheduledPending = nextPending
-        const delay = props.pendingDisplayDelay ?? 120
-        if (delay <= 0) {
-            scheduledPending = undefined
-            setDisplayedPending(nextPending)
-            return
-        }
-
-        pendingTimer = setTimeout(() => {
-            pendingTimer = undefined
-            scheduledPending = undefined
-            if (props.pending() === nextPending) setDisplayedPending(nextPending)
-        }, delay)
-    }
-
-    function setDisplayedPending(nextPending: string | undefined) {
-        if (displayedPending === nextPending) return
-        props.log?.("status.sync", { fromMode: displayedMode, toMode: displayedMode, fromPending: displayedPending, toPending: nextPending })
-        displayedPending = nextPending
-        updatePendingText()
-        props.requestRender?.()
-    }
-}
-
-function modeColor(mode: VimMode, enabled: boolean, theme: PromptContext["api"]["theme"]["current"], disabled?: boolean) {
-    if (!enabled) return undefined
-    if (disabled) return theme.textMuted
-    return mode === "insert" ? theme.success : theme.warning
-}
-
-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.test.ts

@@ -1,211 +0,0 @@
-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
-}