opencode-vim 0.0.12 → 0.0.14

package/bun.lock

@@ -13,6 +13,7 @@
       },
       "devDependencies": {
         "@opencode-ai/plugin": "1.14.44",
+        "@types/bun": "^1.3.14",
       },
     },
   },
@@ -119,6 +120,10 @@
 
     "@standard-schema/spec": ["@standard-schema/spec@1.1.0", "", {}, "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w=="],
 
+    "@types/bun": ["@types/bun@1.3.14", "", { "dependencies": { "bun-types": "1.3.14" } }, "sha512-h1hFqFVcvAvD9j9K7ZW7vd82aSA+rTdznZa+5bwvCwqSB1jmmfLcbIWhOLx1/+boy/xmjgCs/OMUL8hRJSmnPw=="],
+
+    "@types/node": ["@types/node@25.7.0", "", { "dependencies": { "undici-types": "~7.21.0" } }, "sha512-z+pdZyxE+RTQE9AcboAZCb4otwcrvgHD+GlBpPgn0emDVt0ohrTMhAwlr2Wd9nZ+nihhYFxO2pThz3C5qSu2Eg=="],
+
     "@vimee/core": ["@vimee/core@0.3.0", "", {}, "sha512-aC44fw6HhmjrbJMafAk3oUZIDpFbgNebbDsWwMIFD0WwnOUZPETgzU3HYQetmwz0e38JY3I/g8CJXRQjspgJZw=="],
 
     "ansi-regex": ["ansi-regex@6.2.2", "", {}, "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg=="],
@@ -139,6 +144,8 @@
 
     "bun-ffi-structs": ["bun-ffi-structs@0.2.2", "", { "peerDependencies": { "typescript": "^5" } }, "sha512-N/ZWtyN0piZlrXQT7TO0V+q952orYqkfhXRXM1Hcbb+R3QSiBH4vLnib187Mrs1H7pWIYECAmPeapGYDOMCl+w=="],
 
+    "bun-types": ["bun-types@1.3.14", "", { "dependencies": { "@types/node": "*" } }, "sha512-4N0ig0fEomHt5R0KCFWjovxow98rIoRwKolrYdCcknNwMekCXRnWEUvgu5soYV8QXtVsrUD8B95MBOZGPvr6KQ=="],
+
     "caniuse-lite": ["caniuse-lite@1.0.30001791", "", {}, "sha512-yk0l/YSrOnFZk3UROpDLQD9+kC1l4meK/wed583AXrzoarMGJcbRi2Q4RaUYbKxYAsZ8sWmaSa/DsLmdBeI1vQ=="],
 
     "convert-source-map": ["convert-source-map@2.0.0", "", {}, "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="],
@@ -273,6 +280,8 @@
 
     "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
 
+    "undici-types": ["undici-types@7.21.0", "", {}, "sha512-w9IMgQrz4O0YN1LtB7K5P63vhlIOvC7opSmouCJ+ZywlPAlO9gIkJ+otk6LvGpAs2wg4econaCz3TvQ9xPoyuQ=="],
+
     "update-browserslist-db": ["update-browserslist-db@1.2.3", "", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w=="],
 
     "uuid": ["uuid@13.0.1", "", { "bin": { "uuid": "dist-node/bin/uuid" } }, "sha512-9ezox2roIft6ExBVTVqibSd5dc5/47Sw/uY6b4SjQUT2TzQ0tltNquWA46y4xPQmdZYqvnio22SgWd41M86+jw=="],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-vim",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "exports": {
     "./tui": {
       "import": "./tui.tsx"
@@ -14,6 +14,7 @@
     "@vimee/core": "^0.3.0"
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "1.14.44"
+    "@opencode-ai/plugin": "1.14.44",
+    "@types/bun": "^1.3.14"
   }
 }

package/src/modules/snippets/trigger.ts

@@ -1,16 +1,24 @@
 import type { HashtagTriggerMatch, SnippetInfo } from "./types"
 
-const HASHTAG_TRIGGER = /(^|\s)#([^\s#]*)$/
-
 export function findTrailingHashtagTrigger(input: string): HashtagTriggerMatch | undefined {
-    const match = HASHTAG_TRIGGER.exec(input)
-    if (!match) return undefined
+    let start = -1
+    for (let i = input.length - 1; i >= 0; i--) {
+        const char = input[i]
+        if (char === "#") {
+            start = i
+            break
+        }
+        if (/\s/.test(char)) return undefined
+    }
+
+    if (start < 0) return undefined
+    if (start > 0 && !/\s/.test(input[start - 1])) return undefined
 
-    const query = match[2] ?? ""
+    const query = input.slice(start + 1)
     const token = `#${query}`
 
     return {
-        start: input.length - token.length,
+        start,
         end: input.length,
         query,
         token,

package/src/modules/snippets/view.tsx

@@ -82,11 +82,12 @@ export function SnippetAutocomplete(props: SnippetAutocompleteProps) {
     syncInterval = setInterval(() => {
         const ref = props.ctx.prompt()
         if (!ref) {
-            setInput("")
+            if (input()) setInput("")
             setSyncingPrompt(false)
             return
         }
-        setInput(ref.current.input ?? "")
+        const next = ref.current.input ?? ""
+        if (next !== input()) setInput(next)
     }, PROMPT_SYNC_MS)
 
     onCleanup(() => {

package/src/modules/vim/index.tsx

@@ -75,8 +75,6 @@ function VimKeyboard(props: { ctx: PromptContext; config: VimConfig; state: Retu
 
         if (passThroughKey(event, key, props.state.mode())) {
             if (!preparedEvents.delete(event)) preparePassThroughKey(props.ctx, key, props.state.mode())
-            syncCursorStyle(true)
-            props.ctx.requestRender()
             return
         }
 
@@ -90,9 +88,9 @@ function VimKeyboard(props: { ctx: PromptContext; config: VimConfig; state: Retu
         if (consumed) {
             event.preventDefault()
             event.stopPropagation()
+            syncCursorStyle(true)
+            props.ctx.requestRender()
         }
-        syncCursorStyle(true)
-        props.ctx.requestRender()
     })
 
     onCleanup(() => {

package/src/modules/vim/vimee.ts

@@ -10,6 +10,8 @@ import type { createVimState } from "./state"
 
 type VimState = ReturnType<typeof createVimState>
 type HostAction = VimeeAction | { type: "submit" }
+type HostKeybindAction = "normal" | "submit"
+type HostKeybindDefinition = KeybindDefinition & { hostAction?: HostKeybindAction }
 type HostRange = { start: number; end: number }
 
 const YANK_FLASH_MS = 250
@@ -33,11 +35,6 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
             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)
             let vimeeKey = keyForVimee(event, key)
             if (!vimeeKey) return false
 
@@ -46,16 +43,29 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
                 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
+                if (key === "<CR>") {
+                    cancelPendingInsert(ctx)
+                    return false
+                }
+                if (vimeeKey === "Escape") {
+                    cancelPendingInsert(ctx, undefined, false)
+                    enterNormal(ctx)
+                    state.setPending("")
+                    updateTimeout(ctx)
+                    log("vimee.key", { key, mode: vim.mode, phase: vim.phase, cursor: vim.cursor, actions: ["mode-change"] })
+                    return true
+                }
+                return handleInsertKeybind(event, vimeeKey, ctx)
             }
 
+            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 wasPending = keybinds?.isPending() ?? false
             const pendingBefore = pendingInsert
             sync(map, cursor)
@@ -172,20 +182,8 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
         syncVisualSelection(input, currentMap, ctx)
     }
 
-    function handleInsertMode(event: KeyEvent, key: string, ctx: PromptContext, map: PromptMap, cursor: CursorPosition, offset: number) {
-        if (key === "Escape") {
-            cancelPendingInsert(ctx, offset, false)
-            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
+    function handleInsertKeybind(event: KeyEvent, key: string, ctx: PromptContext) {
+        if (!keybinds?.hasKeybinds("insert") && !keybinds?.isPending()) return false
 
         const wasPending = keybinds.isPending()
         const pendingBefore = pendingInsert
@@ -198,25 +196,67 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
                 updateTimeout(ctx)
                 return true
             case "matched": {
-                sync(map, cursor)
-                const actions = applyKeybind(resolved.definition, map)
-                applyActions(actions, ctx, map)
-                syncMode(state, vim.mode)
+                if (applyInsertKeybind(resolved.definition, ctx)) {
+                    pendingInsert = ""
+                    state.setPending("")
+                    updateTimeout(ctx)
+                    log("vimee.keybind", { key, mode: vim.mode, phase: vim.phase, cursor: vim.cursor, actions: ["mode-change"] })
+                    return true
+                }
+
+                if (wasPending && pendingBefore) flushPendingInsert(ctx, pendingBefore)
                 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
+                log("vimee.keybind.unsupported", { key })
+                return false
             }
             case "none":
-                if (wasPending && pendingBefore) flushPendingInsert(ctx, pendingBefore, offset)
+                if (wasPending && pendingBefore) flushPendingInsert(ctx, pendingBefore)
                 pendingInsert = ""
                 state.setPending("")
                 updateTimeout(ctx)
-                return wasPending ? false : undefined
+                return false
+        }
+    }
+
+    function applyInsertKeybind(definition: KeybindDefinition, ctx: PromptContext) {
+        switch (insertHostAction(definition)) {
+            case "normal":
+                enterNormal(ctx)
+                return true
+            case "submit":
+                ctx.prompt()?.submit()
+                return true
+            default:
+                return false
         }
     }
 
+    function enterNormal(ctx: PromptContext) {
+        const ref = ctx.prompt()
+        const input = focusedInput(ctx)
+        const text = input?.plainText ?? ref?.current.input ?? ""
+        const offset = clamp(input?.cursorOffset ?? text.length, 0, text.length)
+
+        if (input && text.length > 0) {
+            input.cursorOffset = Math.max(0, offset - 1)
+            clampNormalCursor(input)
+        }
+
+        vim = { ...resetContext(vim), mode: "normal", statusMessage: "" }
+        nativeInsertUndoSaved = false
+        syncMode(state, "normal")
+    }
+
+    function insertHostAction(definition: KeybindDefinition): HostKeybindAction | undefined {
+        const action = (definition as HostKeybindDefinition).hostAction
+        if (action) return action
+        if ("execute" in definition) return undefined
+        if (definition.keys === "<Esc>" || definition.keys === "<C-[>" || definition.keys === "Escape") return "normal"
+        return undefined
+    }
+
     function applyKeybind(definition: KeybindDefinition, map: PromptMap) {
         if ("execute" in definition) {
             const actions = definition.execute(vim, buffer) as HostAction[]
@@ -299,12 +339,8 @@ export function createVimeeAdapter(state: VimState, config: VimConfig, log: VimL
         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) {
@@ -553,14 +589,14 @@ function createKeybinds(config: VimConfig, log: VimLog): KeybindMap | undefined
     return count > 0 ? map : undefined
 }
 
-function keybindAction(action: string): KeybindDefinition {
+function keybindAction(action: string): HostKeybindDefinition {
     switch (action) {
         case "normal":
-            return { keys: "<Esc>" }
+            return { keys: "<Esc>", hostAction: "normal" }
         case "insert":
             return { keys: "i" }
         case "submit":
-            return { execute: () => [{ type: "submit" } as unknown as VimeeAction] }
+            return { execute: () => [{ type: "submit" } as unknown as VimeeAction], hostAction: "submit" }
         default:
             return { keys: action }
     }

package/src/prompt/root.tsx

@@ -2,24 +2,37 @@
 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"
+import { notifyPromptRef, sortModules } from "./modules"
+import type { PromptContext, PromptRootProps } from "./types"
 
 export function PromptRoot(props: PromptRootProps) {
     const modules = sortModules(props.modules)
     const api = props.api
-    const ctx = createPromptRef(modules, {
+    let current: ReturnType<PromptContext["prompt"]>
+    const ctx: PromptContext = {
         api,
         slot: props.slot,
         kind: props.kind,
-        sessionID: props.sessionID,
-        workspaceID: props.workspaceID,
-        visible: props.visible,
-        disabled: props.disabled,
+        get sessionID() {
+            return props.sessionID
+        },
+        get workspaceID() {
+            return props.workspaceID
+        },
+        get visible() {
+            return props.visible
+        },
+        get disabled() {
+            return props.disabled
+        },
+        prompt: () => current,
+        setPromptRef(ref) {
+            current = ref
+            notifyPromptRef(modules, ref, ctx)
+        },
         submitHost: () => props.onSubmit?.(),
         requestRender: () => api.renderer.requestRender(),
-    })
+    }
 
     const cleanups = modules.flatMap((module) => {
         const cleanup = module.setup?.(ctx)

package/src/prompt/ref.ts

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