opencode-vim 0.0.2

package/src/modules/vim/vimee.ts

@@ -0,0 +1,364 @@
+import type { KeyEvent } from "@opentui/core"
+import { TextBuffer, createInitialContext, createKeybindMap, parseKeySequence, processKeystroke } from "@vimee/core"
+import type { CursorPosition, KeybindDefinition, KeybindMap, ValidKeySequence, VimAction as VimeeAction, VimContext, VimMode as VimeeMode } from "@vimee/core"
+import type { PromptContext } from "../../prompt/types"
+import { focusedInput, setInput, type EditBufferLike } from "./actions"
+import type { VimConfig } from "./config"
+import type { VimLog } from "./log"
+import { createPromptMap, derivePromptMap, hostOffset, hostPosition, type PromptMap } from "./map"
+import type { createVimState } from "./state"
+
+type VimState = ReturnType<typeof createVimState>
+type HostAction = VimeeAction | { type: "submit" }
+
+export type VimeeAdapter = ReturnType<typeof createVimeeAdapter>
+
+export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimLog) {
+    let buffer = new TextBuffer("")
+    let activeMap = createPromptMap("")
+    const maps = new Map([[activeMap.vimText, activeMap]])
+    let vim = createInitialContext({ line: 0, col: 0 })
+    const keybinds = createKeybinds(config, log)
+    let timer: ReturnType<typeof setTimeout> | undefined
+    let pendingInsert = ""
+    let nativeInsertUndoSaved = false
+
+    return {
+        handle(event: KeyEvent, key: string, ctx: PromptContext) {
+            const ref = ctx.prompt()
+            if (!ref) return false
+
+            const input = focusedInput(ctx)
+            const text = input?.plainText ?? ref.current.input
+            const offset = clamp(input?.cursorOffset ?? text.length, 0, text.length)
+            const map = mapForHostText(text, input)
+            const cursor = hostPosition(map, offset)
+            const vimeeKey = keyForVimee(event, key)
+            if (!vimeeKey) return false
+
+            if (state.mode() === "normal" && key === "<CR>") {
+                ref.submit()
+                return true
+            }
+
+            if (state.mode() === "insert" && key === "<CR>") {
+                cancelPendingInsert(ctx, offset)
+                return false
+            }
+
+            if (state.mode() === "insert") {
+                const consumed = handleInsertMode(event, vimeeKey, ctx, map, cursor, offset)
+                return consumed ?? false
+            }
+
+            const wasPending = keybinds?.isPending() ?? false
+            const pendingBefore = pendingInsert
+            sync(map, cursor)
+
+            if (vimeeKey === "A" && appendVisualLine(input, map)) {
+                state.setPending("")
+                updateTimeout(ctx)
+                log("vimee.key", { key, vimeeKey, mode: vim.mode, phase: vim.phase, cursor: vim.cursor, actions: ["mode-change"] })
+                return true
+            }
+
+            const result = processKeystroke(vimeeKey, vim, buffer, event.ctrl, false, keybinds)
+            vim = result.newCtx
+            applyActions(result.actions as HostAction[], ctx, map)
+            syncMode(state, vim.mode)
+            const keybindPending = keybinds?.isPending() ?? false
+            if (wasPending && !keybindPending && pendingBefore && state.mode() === "insert") flushPendingInsert(ctx, pendingBefore, offset)
+            pendingInsert = keybindPending && state.mode() === "insert" ? plainPending(vim.statusMessage) : ""
+            state.setPending(pendingDisplay(vim, keybindPending))
+            updateTimeout(ctx)
+            log("vimee.key", { key, vimeeKey, mode: vim.mode, phase: vim.phase, cursor: vim.cursor, actions: result.actions.map((action) => action.type) })
+            return consumesKey(vimeeKey, result.actions, vim, keybindPending)
+        },
+        cleanup() {
+            if (timer) clearTimeout(timer)
+        },
+    }
+
+    function sync(map: PromptMap, cursor: CursorPosition) {
+        if (buffer.getContent() !== map.vimText) buffer.replaceContent(map.vimText)
+        vim = { ...vim, cursor, mode: state.mode() }
+    }
+
+    function mapForHostText(text: string, input: ReturnType<typeof focusedInput>) {
+        if (activeMap.hostText === text) return activeMap
+        activeMap = createPromptMap(text, input)
+        rememberMap(activeMap)
+        if (state.mode() === "insert") {
+            if (!nativeInsertUndoSaved) {
+                buffer.saveUndoPoint(vim.cursor)
+                nativeInsertUndoSaved = true
+            }
+            buffer.replaceContent(activeMap.vimText)
+        } else {
+            buffer = new TextBuffer(activeMap.vimText)
+            nativeInsertUndoSaved = false
+        }
+        return activeMap
+    }
+
+    function rememberMap(map: PromptMap) {
+        maps.set(map.vimText, map)
+    }
+
+    function nextMap(map: PromptMap, vimText: string) {
+        const known = maps.get(vimText)
+        if (known) return known
+        const next = derivePromptMap(map, vimText)
+        rememberMap(next)
+        return next
+    }
+
+    function applyActions(actions: HostAction[], ctx: PromptContext, map: PromptMap) {
+        const ref = ctx.prompt()
+        const input = focusedInput(ctx)
+        let currentMap = map
+        if (!ref) return
+
+        for (const action of actions) {
+            switch (action.type) {
+                case "content-change":
+                    rememberMap(currentMap)
+                    currentMap = nextMap(currentMap, action.content)
+                    activeMap = currentMap
+                    setInput(ref, currentMap.hostText)
+                    buffer.replaceContent(action.content)
+                    break
+                case "cursor-move":
+                    setCursor(input, currentMap, action.position)
+                    break
+                case "mode-change":
+                    nativeInsertUndoSaved = false
+                    syncMode(state, action.mode)
+                    break
+                case "quit":
+                    ref.blur()
+                    break
+                case "submit":
+                    ref.submit()
+                    break
+            }
+        }
+
+        setCursor(input, currentMap, vim.cursor)
+    }
+
+    function handleInsertMode(event: KeyEvent, key: string, ctx: PromptContext, map: PromptMap, cursor: CursorPosition, offset: number) {
+        if (key === "Escape") {
+            cancelPendingInsert(ctx, offset)
+            sync(map, cursor)
+            const result = processKeystroke(key, vim, buffer, event.ctrl, false)
+            vim = result.newCtx
+            applyActions(result.actions as HostAction[], ctx, map)
+            syncMode(state, vim.mode)
+            state.setPending("")
+            log("vimee.key", { key, mode: vim.mode, phase: vim.phase, cursor: vim.cursor, actions: result.actions.map((action) => action.type) })
+            return true
+        }
+
+        if (!keybinds?.hasKeybinds("insert") && !keybinds?.isPending()) return undefined
+
+        const wasPending = keybinds.isPending()
+        const pendingBefore = pendingInsert
+        const resolved = keybinds.resolve(key, "insert", event.ctrl)
+
+        switch (resolved.status) {
+            case "pending":
+                pendingInsert = plainPending(resolved.display)
+                state.setPending(resolved.display)
+                updateTimeout(ctx)
+                return true
+            case "matched": {
+                sync(map, cursor)
+                const actions = applyKeybind(resolved.definition, map)
+                applyActions(actions, ctx, map)
+                syncMode(state, vim.mode)
+                pendingInsert = ""
+                state.setPending("")
+                updateTimeout(ctx)
+                log("vimee.keybind", { key, mode: vim.mode, phase: vim.phase, cursor: vim.cursor, actions: actions.map((action) => action.type) })
+                return true
+            }
+            case "none":
+                if (wasPending && pendingBefore) flushPendingInsert(ctx, pendingBefore, offset)
+                pendingInsert = ""
+                state.setPending("")
+                updateTimeout(ctx)
+                return wasPending ? false : undefined
+        }
+    }
+
+    function applyKeybind(definition: KeybindDefinition, map: PromptMap) {
+        if ("execute" in definition) {
+            const actions = definition.execute(vim, buffer) as HostAction[]
+            vim = { ...vim, cursor: hostPosition(map, cursorOffset(map, vim.cursor)) }
+            return actions
+        }
+
+        let actions: HostAction[] = []
+        for (const token of parseKeySequence(definition.keys)) {
+            const result = processKeystroke(keyToken(token), vim, buffer, tokenCtrl(token), false)
+            vim = result.newCtx
+            actions = [...actions, ...(result.actions as HostAction[])]
+        }
+        return actions
+    }
+
+    function updateTimeout(ctx: PromptContext) {
+        if (timer) clearTimeout(timer)
+        timer = undefined
+        if (!keybinds?.isPending()) return
+        timer = setTimeout(() => {
+            keybinds.cancel()
+            flushPendingInsert(ctx, pendingInsert)
+            pendingInsert = ""
+            state.setPending("")
+            ctx.requestRender()
+        }, config.keymapTimeout)
+    }
+
+    function cancelPendingInsert(ctx: PromptContext, offset?: number) {
+        if (!keybinds?.isPending()) return
+        if (timer) clearTimeout(timer)
+        timer = undefined
+        keybinds.cancel()
+        flushPendingInsert(ctx, pendingInsert, offset)
+        pendingInsert = ""
+        state.setPending("")
+    }
+
+    function flushPendingInsert(ctx: PromptContext, value: string, offset?: number) {
+        if (!value || state.mode() !== "insert") return
+        const ref = ctx.prompt()
+        if (!ref) return
+        const input = focusedInput(ctx)
+        const text = input?.plainText ?? ref.current.input
+        const insertAt = clamp(offset ?? input?.cursorOffset ?? text.length, 0, text.length)
+        const currentOffset = input?.cursorOffset ?? insertAt
+        const next = text.slice(0, insertAt) + value + text.slice(insertAt)
+        setInput(ref, next)
+        activeMap = createPromptMap(next, input)
+        rememberMap(activeMap)
+        buffer.replaceContent(activeMap.vimText)
+        const nextOffset = currentOffset >= insertAt ? currentOffset + value.length : currentOffset
+        if (input) input.cursorOffset = nextOffset
+        vim = { ...vim, cursor: hostPosition(activeMap, nextOffset) }
+    }
+
+    function cursorOffset(map: PromptMap, position: CursorPosition) {
+        return hostOffset(map, position, vim.mode === "insert" ? "next" : "previous")
+    }
+
+    function setCursor(input: EditBufferLike | undefined, map: PromptMap, position: CursorPosition) {
+        if (!input) return
+        input.cursorOffset = cursorOffset(map, position)
+        if (vim.mode !== "insert") clampNormalCursor(input)
+    }
+
+    function appendVisualLine(input: EditBufferLike | undefined, map: PromptMap) {
+        if (!input?.gotoVisualLineEnd) return false
+        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 clampNormalCursor(input: EditBufferLike) {
+    const cursor = input.visualCursor
+    const eol = input.editorView?.getVisualEOL?.()
+    const offset = input.cursorOffset
+    if (!cursor || !eol || offset === undefined) return
+    if (cursor.visualCol === 0) return
+    if (cursor.visualRow === eol.visualRow && (cursor.offset === eol.offset || offset === eol.offset)) input.cursorOffset = Math.max(0, offset - 1)
+}
+
+function createKeybinds(config: VimConfig, log: VimLog): KeybindMap | undefined {
+    const map = createKeybindMap()
+    let count = 0
+
+    for (const [mode, keymaps] of Object.entries(config.keymaps) as Array<[VimeeMode, Record<string, string> | undefined]>) {
+        if (!keymaps) continue
+        for (const [keys, action] of Object.entries(keymaps)) {
+            try {
+                map.addKeybind(mode, keys as ValidKeySequence<typeof keys>, keybindAction(action))
+                count++
+            } catch (error) {
+                log("vimee.keymap.invalid", { mode, keys, action, error: error instanceof Error ? error.message : String(error) })
+            }
+        }
+    }
+
+    return count > 0 ? map : undefined
+}
+
+function keybindAction(action: string): KeybindDefinition {
+    switch (action) {
+        case "normal":
+            return { keys: "<Esc>" }
+        case "insert":
+            return { keys: "i" }
+        case "submit":
+            return { execute: () => [{ type: "submit" } as unknown as VimeeAction] }
+        default:
+            return { keys: action }
+    }
+}
+
+function keyForVimee(event: KeyEvent, key: string) {
+    if (event.ctrl) return event.name?.toLowerCase()
+    const token = keyToken(key)
+    return token.startsWith("<") ? undefined : token
+}
+
+function keyToken(token: string) {
+    if (token === "<Esc>" || token === "<C-[>") return "Escape"
+    if (token === "<CR>") return "Enter"
+    if (token === "<Tab>") return "Tab"
+    if (token === "<BS>") return "Backspace"
+    if (token === "<Del>") return "Delete"
+    if (token === "<Space>") return " "
+    if (token === "<Up>") return "ArrowUp"
+    if (token === "<Down>") return "ArrowDown"
+    if (token === "<Left>") return "ArrowLeft"
+    if (token === "<Right>") return "ArrowRight"
+    if (token === "<Home>") return "Home"
+    if (token === "<End>") return "End"
+    if (token.startsWith("<C-") && token.endsWith(">")) return token.slice(3, -1).toLowerCase()
+    return token
+}
+
+function tokenCtrl(token: string) {
+    return token.startsWith("<C-") && token !== "<C-[>"
+}
+
+function syncMode(state: VimState, mode: VimContext["mode"]) {
+    state.setMode(mode === "insert" ? "insert" : "normal")
+}
+
+function pendingDisplay(ctx: VimContext, keybindPending: boolean) {
+    if (ctx.phase === "operator-pending") return ctx.operator ?? ""
+    if (ctx.phase === "text-object-pending") return ctx.textObjectModifier ?? ""
+    if (keybindPending) return ctx.statusMessage
+    return ""
+}
+
+function plainPending(value: string) {
+    return value.includes("<") || value.includes(">") ? "" : value
+}
+
+function consumesKey(key: string, actions: VimeeAction[], ctx: VimContext, keybindPending: boolean) {
+    if (actions.length > 0) return true
+    if (keybindPending) return true
+    if (ctx.phase !== "idle") return true
+    return ctx.mode !== "insert" || key === "Escape"
+}
+
+function clamp(value: number, min: number, max: number) {
+    return Math.max(min, Math.min(max, value))
+}

package/src/plugin.tsx

@@ -0,0 +1,69 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui"
+import { PromptRoot } from "./prompt/root"
+import type { PromptModule } from "./prompt/types"
+import { createVimModule } from "./modules/vim"
+import { createSnippetsModule } from "./modules/snippets"
+
+const tui: TuiPlugin = async (api, options) => {
+    const moduleCache = new Map<string, PromptModule[]>()
+    const createModules = (key: string) => {
+        const cached = moduleCache.get(key)
+        if (cached) return cached
+
+        const modules: PromptModule[] = []
+        if (hasSnippetsPlugin(api)) modules.push(createSnippetsModule())
+        modules.push(createVimModule(options))
+        moduleCache.set(key, modules)
+        return modules
+    }
+
+    api.slots.register({
+        order: 50,
+        slots: {
+            home_prompt(ctx, props) {
+                return <PromptRoot api={api} slot={ctx} kind="home" workspaceID={props.workspace_id} ref={props.ref} modules={createModules(`home:${props.workspace_id ?? ""}`)} />
+            },
+            session_prompt(ctx, props) {
+                return (
+                    <PromptRoot
+                        api={api}
+                        slot={ctx}
+                        kind="session"
+                        sessionID={props.session_id}
+                        visible={props.visible}
+                        disabled={props.disabled}
+                        onSubmit={props.on_submit}
+                        ref={props.ref}
+                        modules={createModules(`session:${props.session_id}`)}
+                    />
+                )
+            },
+        },
+    })
+}
+
+function hasSnippetsPlugin(api: TuiPluginApi) {
+    return configHasSnippets(api.state.config.plugin) || configHasSnippets(api.tuiConfig.plugin) || api.plugins.list().some(pluginHasSnippets)
+}
+
+function configHasSnippets(plugins: unknown) {
+    if (!Array.isArray(plugins)) return false
+    return plugins.some((plugin) => specHasSnippets(Array.isArray(plugin) ? plugin[0] : plugin))
+}
+
+function pluginHasSnippets(plugin: ReturnType<TuiPluginApi["plugins"]["list"]>[number]) {
+    return plugin.enabled && (specHasSnippets(plugin.id) || specHasSnippets(plugin.spec))
+}
+
+function specHasSnippets(spec: unknown) {
+    if (typeof spec !== "string") return false
+    return spec === "opencode-snippets" || spec.startsWith("opencode-snippets@") || spec.includes("/opencode-snippets")
+}
+
+const plugin: TuiPluginModule & { id: string } = {
+    id: "local.opencode-vim",
+    tui,
+}
+
+export default plugin

package/src/prompt/host.tsx

@@ -0,0 +1,38 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPromptRef } from "@opencode-ai/plugin/tui"
+import type { JSX } from "@opentui/solid"
+import type { PromptContext, PromptModule } from "./types"
+import { submitModules } from "./modules"
+
+type HostPromptProps = {
+    ctx: PromptContext
+    modules: PromptModule[]
+    ref?: (ref: TuiPromptRef | undefined) => void
+    right?: JSX.Element
+}
+
+export function HostPrompt(props: HostPromptProps) {
+    const api = props.ctx.api
+
+    const setRef = (ref: TuiPromptRef | undefined) => {
+        props.ctx.setPromptRef(ref)
+        props.ref?.(ref)
+    }
+
+    const onSubmit = () => {
+        if (submitModules(props.modules, props.ctx)) return
+        props.ctx.submitHost()
+    }
+
+    return (
+        <api.ui.Prompt
+            sessionID={props.ctx.sessionID}
+            workspaceID={props.ctx.workspaceID}
+            visible={props.ctx.visible}
+            disabled={props.ctx.disabled}
+            onSubmit={onSubmit}
+            ref={setRef}
+            right={props.right}
+        />
+    )
+}

package/src/prompt/modules.ts

@@ -0,0 +1,16 @@
+import type { PromptContext, PromptModule } from "./types"
+
+export function sortModules(modules: PromptModule[]) {
+    return [...modules].sort((left, right) => (left.order ?? 0) - (right.order ?? 0) || left.id.localeCompare(right.id))
+}
+
+export function submitModules(modules: PromptModule[], ctx: PromptContext) {
+    for (const module of modules) {
+        if (module.onSubmit?.(ctx) === true) return true
+    }
+    return false
+}
+
+export function notifyPromptRef(modules: PromptModule[], ref: ReturnType<PromptContext["prompt"]>, ctx: PromptContext) {
+    for (const module of modules) module.onPromptRef?.(ref, ctx)
+}

package/src/prompt/ref.ts

@@ -0,0 +1,17 @@
+import type { TuiPromptRef } from "@opencode-ai/plugin/tui"
+import type { PromptContext, PromptModule } from "./types"
+import { notifyPromptRef } from "./modules"
+
+export function createPromptRef(modules: PromptModule[], ctx: Omit<PromptContext, "prompt" | "setPromptRef">) {
+    let current: TuiPromptRef | undefined
+    const context = {
+        ...ctx,
+        prompt: () => current,
+        setPromptRef(ref: TuiPromptRef | undefined) {
+            current = ref
+            notifyPromptRef(modules, ref, context)
+        },
+    } satisfies PromptContext
+
+    return context
+}

package/src/prompt/root.tsx

@@ -0,0 +1,56 @@
+/** @jsxImportSource @opentui/solid */
+import { onCleanup } from "solid-js"
+import type { JSX } from "@opentui/solid"
+import { HostPrompt } from "./host"
+import { sortModules } from "./modules"
+import { createPromptRef } from "./ref"
+import type { PromptRootProps } from "./types"
+
+export function PromptRoot(props: PromptRootProps) {
+    const modules = sortModules(props.modules)
+    const api = props.api
+    const ctx = createPromptRef(modules, {
+        api,
+        slot: props.slot,
+        kind: props.kind,
+        sessionID: props.sessionID,
+        workspaceID: props.workspaceID,
+        visible: props.visible,
+        disabled: props.disabled,
+        submitHost: () => props.onSubmit?.(),
+        requestRender: () => api.renderer.requestRender(),
+    })
+
+    const cleanups = modules.flatMap((module) => {
+        const cleanup = module.setup?.(ctx)
+        return typeof cleanup === "function" ? [cleanup] : []
+    })
+    onCleanup(() => {
+        for (const cleanup of cleanups) cleanup()
+    })
+
+    const moduleAbove = modules.map((module) => module.renderAbove?.(ctx)).filter(Boolean) as JSX.Element[]
+    const moduleBelow = modules.map((module) => module.renderBelow?.(ctx)).filter(Boolean) as JSX.Element[]
+    const moduleRight = modules.map((module) => module.renderRight?.(ctx)).filter(Boolean) as JSX.Element[]
+    const hostRight = renderHostRight(props)
+
+    return (
+        <box>
+            {moduleAbove}
+            <HostPrompt ctx={ctx} modules={modules} ref={props.ref} right={<RightItems items={[...moduleRight, hostRight]} />} />
+            {moduleBelow}
+        </box>
+    )
+}
+
+function renderHostRight(props: PromptRootProps) {
+    const Slot = props.api.ui.Slot
+    if (props.kind === "home") return <Slot name="home_prompt_right" workspace_id={props.workspaceID} />
+    return <Slot name="session_prompt_right" session_id={props.sessionID ?? ""} />
+}
+
+function RightItems(props: { items: JSX.Element[] }) {
+    const items = props.items.filter(Boolean)
+    if (items.length === 0) return undefined
+    return <box flexDirection="row">{items}</box>
+}

package/src/prompt/types.ts

@@ -0,0 +1,42 @@
+import type { JSX } from "@opentui/solid"
+import type { TuiPluginApi, TuiPromptRef, TuiSlotContext } from "@opencode-ai/plugin/tui"
+
+export type PromptKind = "home" | "session"
+
+export type PromptContext = {
+    api: TuiPluginApi
+    slot: TuiSlotContext
+    kind: PromptKind
+    sessionID?: string
+    workspaceID?: string
+    visible?: boolean
+    disabled?: boolean
+    prompt: () => TuiPromptRef | undefined
+    setPromptRef: (ref: TuiPromptRef | undefined) => void
+    submitHost: () => void
+    requestRender: () => void
+}
+
+export type PromptModule = {
+    id: string
+    order?: number
+    setup?: (ctx: PromptContext) => void | (() => void)
+    onPromptRef?: (ref: TuiPromptRef | undefined, ctx: PromptContext) => void
+    onSubmit?: (ctx: PromptContext) => boolean | void
+    renderAbove?: (ctx: PromptContext) => JSX.Element
+    renderBelow?: (ctx: PromptContext) => JSX.Element
+    renderRight?: (ctx: PromptContext) => JSX.Element
+}
+
+export type PromptRootProps = {
+    api: TuiPluginApi
+    slot: TuiSlotContext
+    kind: PromptKind
+    sessionID?: string
+    workspaceID?: string
+    visible?: boolean
+    disabled?: boolean
+    onSubmit?: () => void
+    ref?: (ref: TuiPromptRef | undefined) => void
+    modules: PromptModule[]
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid",
+    "skipLibCheck": true,
+    "types": ["bun-types"]
+  },
+  "include": ["./tui.tsx", "./src/**/*.ts", "./src/**/*.tsx"]
+}

package/tui.json.example

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://opencode.ai/tui.json",
+  "plugin": [
+    [
+      "./plugin/opencode-vim",
+      {
+        "vim": {
+          "defaultMode": "insert",
+          "keymapTimeout": 500,
+          "pendingDisplayDelay": 120,
+          "cursorStyles": {
+            "insert": {
+              "style": "line",
+              "blinking": true
+            },
+            "normal": {
+              "style": "block",
+              "blinking": true
+            }
+          },
+          "debug": false,
+          "debugPath": "/home/you/.cache/opencode/opencode-vim.log",
+          "keymaps": {
+            "insert": {
+              "kj": "normal"
+            },
+            "normal": {
+              "i": "insert",
+              "<CR>": "submit",
+              "Y": "y$"
+            }
+          }
+        }
+      }
+    ]
+  ]
+}

package/tui.tsx

@@ -0,0 +1 @@
+export { default } from "./src/plugin"