opencode-vim 0.0.2

package/src/modules/vim/config.ts

@@ -0,0 +1,119 @@
+import type { VimMode } from "./state"
+
+export type VimCursorStyle = {
+    style: "block" | "line" | "underline" | "default"
+    blinking?: boolean
+}
+
+export type VimConfig = {
+    defaultMode: VimMode
+    keymapTimeout: number
+    pendingDisplayDelay: number
+    cursorStyles: Record<VimMode, VimCursorStyle>
+    debug: boolean
+    debugPath?: string
+    keymaps: VimKeymaps
+}
+
+export type VimOptions = {
+    defaultMode?: VimMode
+    keymapTimeout?: number
+    pendingDisplayDelay?: number
+    cursorStyles?: Partial<Record<VimMode, VimCursorStyle>>
+    debug?: boolean
+    debugPath?: string
+    keymaps?: VimKeymaps
+}
+
+export type VimKeymaps = Partial<Record<VimMode, Record<string, VimMappedAction>>>
+export type VimMappedAction = string
+
+const DEFAULT_CURSOR_STYLES: Record<VimMode, VimCursorStyle> = {
+    insert: { style: "line", blinking: true },
+    normal: { style: "block", blinking: true },
+}
+
+export function createVimConfig(options: unknown): VimConfig {
+    const input = readOptions(options)
+    return {
+        defaultMode: input.defaultMode ?? "insert",
+        keymapTimeout: Math.max(0, input.keymapTimeout ?? 500),
+        pendingDisplayDelay: Math.max(0, input.pendingDisplayDelay ?? 120),
+        cursorStyles: {
+            insert: { ...DEFAULT_CURSOR_STYLES.insert, ...input.cursorStyles?.insert },
+            normal: { ...DEFAULT_CURSOR_STYLES.normal, ...input.cursorStyles?.normal },
+        },
+        debug: input.debug ?? process.env.VIM_PROMPT_DEBUG === "1",
+        debugPath: input.debugPath,
+        keymaps: input.keymaps ?? {},
+    }
+}
+
+function readOptions(options: unknown): VimOptions {
+    if (!options || typeof options !== "object") return {}
+    const raw = "vim" in options ? (options as { vim?: unknown }).vim : options
+    if (!raw || typeof raw !== "object") return {}
+
+    const source = raw as Record<string, unknown>
+    return {
+        defaultMode: isMode(source.defaultMode) ? source.defaultMode : undefined,
+        keymapTimeout: readNumber(source.keymapTimeout),
+        pendingDisplayDelay: typeof source.pendingDisplayDelay === "number" ? source.pendingDisplayDelay : undefined,
+        cursorStyles: readCursorStyles(source.cursorStyles),
+        debug: typeof source.debug === "boolean" ? source.debug : undefined,
+        debugPath: typeof source.debugPath === "string" ? source.debugPath : undefined,
+        keymaps: readKeymaps(source.keymaps),
+    }
+}
+
+function readKeymaps(input: unknown): VimKeymaps | undefined {
+    if (!input || typeof input !== "object") return undefined
+    const source = input as Record<string, unknown>
+    const keymaps: VimKeymaps = {}
+
+    for (const mode of ["insert", "normal"] as const) {
+        const raw = source[mode]
+        if (!raw || typeof raw !== "object") continue
+        keymaps[mode] = {}
+        for (const [key, action] of Object.entries(raw as Record<string, unknown>)) {
+            if (isMappedAction(action)) keymaps[mode][key] = action
+        }
+    }
+
+    return keymaps
+}
+
+function readCursorStyles(input: unknown): VimOptions["cursorStyles"] {
+    if (!input || typeof input !== "object") return undefined
+    const source = input as Record<string, unknown>
+    return {
+        insert: readCursorStyle(source.insert),
+        normal: readCursorStyle(source.normal),
+    }
+}
+
+function readCursorStyle(input: unknown): VimCursorStyle | undefined {
+    if (!input || typeof input !== "object") return undefined
+    const source = input as Record<string, unknown>
+    if (!isCursorStyle(source.style)) return undefined
+    return {
+        style: source.style,
+        blinking: typeof source.blinking === "boolean" ? source.blinking : undefined,
+    }
+}
+
+function isCursorStyle(value: unknown): value is VimCursorStyle["style"] {
+    return value === "block" || value === "line" || value === "underline" || value === "default"
+}
+
+function isMode(value: unknown): value is VimMode {
+    return value === "insert" || value === "normal"
+}
+
+function isMappedAction(value: unknown): value is VimMappedAction {
+    return typeof value === "string" && value.length > 0
+}
+
+function readNumber(value: unknown) {
+    return typeof value === "number" ? value : undefined
+}

package/src/modules/vim/index.tsx

@@ -0,0 +1,96 @@
+/** @jsxImportSource @opentui/solid */
+import { useKeyboard } from "@opentui/solid"
+import { onCleanup } from "solid-js"
+import type { PromptContext, PromptModule } from "../../prompt/types"
+import { applyVimCursorStyle } from "./actions"
+import type { VimConfig } from "./config"
+import { createVimConfig } from "./config"
+import { keyNotation } from "./keys"
+import { createVimLog } from "./log"
+import type { VimLog } from "./log"
+import { createVimState } from "./state"
+import { createVimeeAdapter } from "./vimee"
+import { VimStatus } from "./view"
+
+export function createVimModule(options?: unknown): PromptModule {
+    const config = createVimConfig(options)
+    const log = createVimLog(config)
+    const state = createVimState(config.defaultMode, log)
+    log("module.create", { defaultMode: config.defaultMode, keymapTimeout: config.keymapTimeout })
+
+    return {
+        id: "vim",
+        order: 0,
+        setup(ctx) {
+            log("module.setup", { kind: ctx.kind, sessionID: ctx.sessionID, workspaceID: ctx.workspaceID })
+        },
+        renderAbove(ctx) {
+            return <VimKeyboard ctx={ctx} config={config} state={state} log={log} />
+        },
+        renderRight(ctx) {
+            return <VimStatus mode={state.mode} pending={() => readablePending(state.pending())} theme={ctx.api.theme.current} pendingDisplayDelay={config.pendingDisplayDelay} disabled={ctx.disabled} log={log} requestRender={ctx.requestRender} />
+        },
+    }
+}
+
+function VimKeyboard(props: { ctx: PromptContext; config: VimConfig; state: ReturnType<typeof createVimState>; log: VimLog }) {
+    let cursorStyleMode = ""
+    const vimee = createVimeeAdapter(props.state, props.config, props.log)
+    props.log("keyboard.mount", { kind: props.ctx.kind })
+
+    const cursorStyleTimer = setInterval(syncCursorStyle, 50)
+
+    useKeyboard((event) => {
+        props.log("keyboard.event", {
+            name: event.name,
+            ctrl: event.ctrl,
+            meta: event.meta,
+            shift: event.shift,
+            defaultPrevented: event.defaultPrevented,
+            propagationStopped: event.propagationStopped,
+            mode: props.state.mode(),
+            pending: props.state.pending(),
+        })
+
+        if (props.ctx.disabled || props.ctx.visible === false) {
+            props.log("keyboard.skip", { disabled: props.ctx.disabled, visible: props.ctx.visible })
+            return
+        }
+
+        const key = keyNotation(event)
+        if (!key) {
+            props.log("keyboard.no_key")
+            return
+        }
+
+        const consumed = vimee.handle(event, key, props.ctx)
+        if (consumed) {
+            event.preventDefault()
+            event.stopPropagation()
+        }
+        syncCursorStyle(true)
+        props.ctx.requestRender()
+    })
+
+    onCleanup(() => {
+        props.log("keyboard.cleanup", { kind: props.ctx.kind })
+        vimee.cleanup()
+        clearInterval(cursorStyleTimer)
+    })
+
+    return <box height={0} />
+
+    function syncCursorStyle(force = false) {
+        const mode = props.state.mode()
+        if (!force && cursorStyleMode === mode) return
+        if (applyVimCursorStyle(props.ctx, props.config.cursorStyles[mode])) {
+            cursorStyleMode = mode
+            props.log("cursor.style", { mode, style: props.config.cursorStyles[mode].style, blinking: props.config.cursorStyles[mode].blinking })
+        }
+    }
+}
+
+function readablePending(sequence: string) {
+    if (!sequence) return undefined
+    return sequence.replaceAll("><", " ")
+}

package/src/modules/vim/keys.ts

@@ -0,0 +1,34 @@
+import type { KeyEvent } from "@opentui/core"
+
+const NAMED_KEYS: Record<string, string> = {
+    escape: "<Esc>",
+    esc: "<Esc>",
+    return: "<CR>",
+    enter: "<CR>",
+    tab: "<Tab>",
+    backspace: "<BS>",
+    delete: "<Del>",
+    space: "<Space>",
+    up: "<Up>",
+    down: "<Down>",
+    left: "<Left>",
+    right: "<Right>",
+    home: "<Home>",
+    end: "<End>",
+}
+
+export function keyNotation(event: KeyEvent) {
+    const name = event.name?.toLowerCase()
+    if (!name) return undefined
+
+    if (event.ctrl) return `<C-${ctrlKey(name)}>`
+    if (event.meta) return `<M-${name}>`
+    if (name.length === 1) return event.shift ? name.toUpperCase() : name
+    return NAMED_KEYS[name] ?? `<${name}>`
+}
+
+function ctrlKey(name: string) {
+    if (name === "escape" || name === "esc") return "["
+    if (name.length === 1) return name
+    return name
+}

package/src/modules/vim/log.ts

@@ -0,0 +1,37 @@
+import { appendFile, mkdir } from "node:fs/promises"
+import { dirname, join } from "node:path"
+import type { VimConfig } from "./config"
+
+export type VimLog = (event: string, data?: Record<string, unknown>) => void
+
+export function createVimLog(config: VimConfig): VimLog {
+    if (!config.debug) return () => {}
+
+    const path = config.debugPath ?? defaultPath()
+    void append(path, `\n--- opencode-vim debug ${new Date().toISOString()} ---\n`)
+
+    return (event, data) => {
+        const suffix = data ? ` ${safeJson(data)}` : ""
+        void append(path, `${new Date().toISOString()} ${event}${suffix}\n`)
+    }
+}
+
+function defaultPath() {
+    const home = process.env.HOME
+    return home ? join(home, ".cache/opencode/opencode-vim.log") : "/tmp/opencode-vim.log"
+}
+
+async function append(path: string, text: string) {
+    try {
+        await mkdir(dirname(path), { recursive: true })
+        await appendFile(path, text)
+    } catch {}
+}
+
+function safeJson(data: Record<string, unknown>) {
+    try {
+        return JSON.stringify(data)
+    } catch {
+        return "{}"
+    }
+}

package/src/modules/vim/map.ts

@@ -0,0 +1,159 @@
+import type { CursorPosition } from "@vimee/core"
+import type { EditBufferLike } from "./actions"
+
+export type PromptMap = {
+    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 derivePromptMap(map: PromptMap, vimText: string): PromptMap {
+    const prefix = commonPrefix(map.vimText, vimText)
+    const suffix = commonSuffix(map.vimText, vimText, prefix)
+    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) {
+            synthetic.add(vimOffset)
+            continue
+        }
+
+        hostText += vimText[vimOffset]
+    }
+
+    return buildPromptMapFromSynthetic(hostText, vimText, synthetic)
+}
+
+export function hostPosition(map: PromptMap, hostOffset: number): CursorPosition {
+    return positionFromOffset(map.vimText, map.hostToVim[clamp(hostOffset, 0, map.hostText.length)] ?? 0)
+}
+
+export function hostOffset(map: PromptMap, position: CursorPosition, bias: "previous" | "next" = "next") {
+    return hostOffsetFromVimOffset(map, offsetFromPosition(map.vimText, position), bias)
+}
+
+function buildPromptMap(hostText: string, wraps: number[]): 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++) {
+        if (wrapOffsets.has(hostOffset)) {
+            vimText += "\n"
+            vimToHost[vimOffset] = undefined
+            vimOffset++
+        }
+        hostToVim[hostOffset] = vimOffset
+        vimText += hostText[hostOffset]
+        vimToHost[vimOffset] = hostOffset
+        vimOffset++
+    }
+
+    hostToVim[hostText.length] = vimOffset
+    return { hostText, vimText, hostToVim, vimToHost }
+}
+
+function buildPromptMapFromSynthetic(hostText: string, vimText: string, synthetic: Set<number>): 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
+        }
+
+        hostToVim[hostOffset] = vimOffset
+        vimToHost[vimOffset] = hostOffset
+        hostOffset++
+    }
+
+    hostToVim[hostText.length] = vimText.length
+    return { hostText, vimText, hostToVim, vimToHost }
+}
+
+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 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
+        }
+        if (previousRow !== undefined && row > previousRow && text[offset - 1] !== "\n") wraps.push(offset)
+        previousRow = row
+    }
+
+    input.cursorOffset = original
+    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.ts

@@ -0,0 +1,24 @@
+import { createSignal } from "solid-js"
+import type { VimLog } from "./log"
+
+export type VimMode = "normal" | "insert"
+
+export function createVimState(defaultMode: VimMode, log: VimLog = () => {}) {
+    const [mode, setMode] = createSignal<VimMode>(defaultMode)
+    const [pending, setPending] = createSignal("")
+
+    log("state.init", { mode: defaultMode })
+
+    return {
+        mode,
+        setMode(next: VimMode) {
+            if (mode() !== next) log("state.mode", { from: mode(), to: next })
+            setMode(next)
+        },
+        pending,
+        setPending(next: string) {
+            if (pending() !== next) log("state.pending", { from: pending(), to: next })
+            setPending(next)
+        },
+    }
+}

package/src/modules/vim/view.tsx

@@ -0,0 +1,86 @@
+/** @jsxImportSource @opentui/solid */
+import { createSignal, onCleanup } from "solid-js"
+import type { Accessor } from "solid-js"
+import type { PromptContext } from "../../prompt/types"
+import type { VimLog } from "./log"
+import type { VimMode } from "./state"
+
+const STATUS_SYNC_MS = 50
+
+type VimStatusProps = {
+    mode: Accessor<VimMode>
+    pending: Accessor<string | undefined>
+    theme: PromptContext["api"]["theme"]["current"]
+    pendingDisplayDelay?: number
+    disabled?: boolean
+    log?: VimLog
+    requestRender?: () => void
+}
+
+export function VimStatus(props: VimStatusProps) {
+    const [mode, setMode] = createSignal(props.mode())
+    const [pending, setPending] = createSignal<string | undefined>()
+    let pendingTimer: ReturnType<typeof setTimeout> | undefined
+    let scheduledPending: string | undefined
+
+    const sync = () => {
+        const nextMode = props.mode()
+        const nextPending = props.pending()
+
+        if (mode() !== nextMode) {
+            props.log?.("status.sync", { fromMode: mode(), toMode: nextMode, fromPending: pending(), toPending: pending() })
+            setMode(nextMode)
+            props.requestRender?.()
+        }
+
+        syncPending(nextPending)
+    }
+
+    const timer = setInterval(sync, STATUS_SYNC_MS)
+    onCleanup(() => {
+        clearInterval(timer)
+        if (pendingTimer) clearTimeout(pendingTimer)
+    })
+
+    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>
+        </box>
+    )
+
+    function syncPending(nextPending: string | undefined) {
+        if (!nextPending) {
+            if (pendingTimer) clearTimeout(pendingTimer)
+            pendingTimer = undefined
+            scheduledPending = undefined
+            setDisplayedPending(undefined)
+            return
+        }
+
+        if (pending() === 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 (pending() === nextPending) return
+        props.log?.("status.sync", { fromMode: mode(), toMode: mode(), fromPending: pending(), toPending: nextPending })
+        setPending(nextPending)
+        props.requestRender?.()
+    }
+}