opencode-vim 0.0.22 → 0.0.24

package/src/plugin.tsx

@@ -1,116 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui"
-import { createSignal } from "solid-js"
-import { PromptRoot } from "./prompt/root"
-import type { PromptModule } from "./prompt/types"
-import { createVimModule } from "./modules/vim"
-import { createSnippetsModule } from "./modules/snippets"
-import type { SnippetController } from "./modules/snippets/types"
-import { checkAutoUpdate } from "./update"
-
-const tui: TuiPlugin = async (api, options, meta) => {
-    const vimEnabledKey = `${meta.id}:enabled`
-    const [vimEnabled, setVimEnabled] = createSignal(api.kv.get(vimEnabledKey, true) === true)
-
-    api.keymap.registerLayer({
-        commands: [
-            {
-                namespace: "palette",
-                name: "opencode-vim.toggle",
-                title: "Toggle Vim Mode",
-                desc: "Enable or disable Vim key handling",
-                category: "Vim",
-                slashName: "vim",
-                run() {
-                    const next = !vimEnabled()
-                    setVimEnabled(next)
-                    api.kv.set(vimEnabledKey, next)
-                    api.ui.toast({ variant: "info", message: `Vim mode ${next ? "enabled" : "disabled"}` })
-                },
-            },
-        ],
-    })
-
-    if (readAutoUpdate(options)) {
-        let timer: Timer | undefined
-        api.lifecycle.onDispose(() => {
-            if (timer) clearTimeout(timer)
-        })
-
-        void checkAutoUpdate(meta, api.lifecycle.signal).then((result) => {
-            if (!result.updated) return
-
-            timer = setTimeout(() => {
-                api.ui.toast({ variant: "info", message: "Updating opencode-vim. Restart OpenCode to finish." })
-            }, 5000)
-        }).catch(() => {})
-    }
-
-    const moduleCache = new Map<string, PromptModule[]>()
-    const createModules = (key: string) => {
-        const cached = moduleCache.get(key)
-        if (cached) return cached
-
-        const modules: PromptModule[] = []
-        const snippets: SnippetController = {}
-        if (hasSnippetsPlugin(api)) modules.push(createSnippetsModule(snippets))
-        modules.push(createVimModule(options, vimEnabled, snippets))
-        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 readAutoUpdate(options: unknown) {
-    if (!options || typeof options !== "object") return true
-    const value = (options as { autoUpdate?: unknown }).autoUpdate
-    return typeof value === "boolean" ? value : true
-}
-
-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

@@ -1,38 +0,0 @@
-/** @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

@@ -1,16 +0,0 @@
-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/root.tsx

@@ -1,69 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { onCleanup } from "solid-js"
-import type { JSX } from "@opentui/solid"
-import { HostPrompt } from "./host"
-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
-    let current: ReturnType<PromptContext["prompt"]>
-    const ctx: PromptContext = {
-        api,
-        slot: props.slot,
-        kind: props.kind,
-        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)
-        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

@@ -1,42 +0,0 @@
-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/src/update.ts

@@ -1,120 +0,0 @@
-import { rm } from "node:fs/promises"
-import { basename, dirname, join } from "node:path"
-import { fileURLToPath } from "node:url"
-import type { TuiPluginMeta } from "@opencode-ai/plugin/tui"
-
-type PackageJson = {
-    name?: string
-    version?: string
-    dependencies?: Record<string, string>
-}
-
-type UpdateResult =
-    | { updated: true; name: string; current: string; latest: string }
-    | { updated: false; error: "remove_failed"; name: string; current: string; latest: string }
-    | { updated: false }
-
-export async function checkAutoUpdate(meta: TuiPluginMeta, signal: AbortSignal): Promise<UpdateResult> {
-    if (meta.source !== "npm") return { updated: false }
-
-    const packageDir = await findPackageDir()
-    if (!packageDir) return { updated: false }
-
-    const pkg = await readPackageJson(join(packageDir, "package.json"))
-    if (!pkg.name || !pkg.version) return { updated: false }
-
-    const latest = await fetchLatestVersion(pkg.name, signal)
-    if (!latest || !isVersionNewer(latest, pkg.version)) return { updated: false }
-
-    const removeDir = await updateRemoveDir(packageDir, pkg.name)
-    try {
-        await rm(removeDir, { recursive: true, force: true })
-    } catch {
-        return { updated: false, error: "remove_failed", name: pkg.name, current: pkg.version, latest }
-    }
-
-    return { updated: true, name: pkg.name, current: pkg.version, latest }
-}
-
-async function findPackageDir() {
-    let dir = dirname(fileURLToPath(import.meta.url))
-    for (;;) {
-        const packagePath = join(dir, "package.json")
-        const pkg = await readPackageJson(packagePath)
-        if (pkg?.name === "opencode-vim") return dir
-
-        const parent = dirname(dir)
-        if (parent === dir) return undefined
-        dir = parent
-    }
-}
-
-async function updateRemoveDir(packageDir: string, name: string) {
-    const nodeModulesDir = dirname(packageDir)
-    if (basename(nodeModulesDir) !== "node_modules") return packageDir
-
-    const wrapperDir = dirname(nodeModulesDir)
-    const wrapperPkg = await readPackageJson(join(wrapperDir, "package.json"))
-    return wrapperPkg?.dependencies?.[name] ? wrapperDir : packageDir
-}
-
-async function readPackageJson(path: string): Promise<PackageJson | undefined> {
-    try {
-        const file = Bun.file(path)
-        if (!(await file.exists())) return undefined
-        const data = await file.json()
-        return data && typeof data === "object" ? (data as PackageJson) : undefined
-    } catch {
-        return undefined
-    }
-}
-
-async function fetchLatestVersion(name: string, signal: AbortSignal) {
-    try {
-        const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(name)}/latest`, { signal })
-        if (!response.ok) return undefined
-        const data = await response.json()
-        return data && typeof data === "object" && typeof data.version === "string" ? data.version : undefined
-    } catch {
-        return undefined
-    }
-}
-
-function isVersionNewer(latest: string, current: string) {
-    const next = parseVersion(latest)
-    const prev = parseVersion(current)
-    if (!next || !prev) return false
-
-    for (let i = 0; i < 3; i++) {
-        if (next.parts[i] !== prev.parts[i]) return next.parts[i] > prev.parts[i]
-    }
-
-    if (!next.pre.length && prev.pre.length) return true
-    if (next.pre.length && !prev.pre.length) return false
-
-    for (let i = 0; i < Math.max(next.pre.length, prev.pre.length); i++) {
-        const a = next.pre[i]
-        const b = prev.pre[i]
-        if (a === undefined) return false
-        if (b === undefined) return true
-        if (a === b) continue
-
-        const aNumber = /^\d+$/.test(a) ? Number(a) : undefined
-        const bNumber = /^\d+$/.test(b) ? Number(b) : undefined
-        if (aNumber !== undefined && bNumber !== undefined) return aNumber > bNumber
-        if (aNumber !== undefined) return false
-        if (bNumber !== undefined) return true
-        return a > b
-    }
-
-    return false
-}
-
-function parseVersion(version: string) {
-    const match = version.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.+)?$/)
-    if (!match) return undefined
-    return {
-        parts: [Number(match[1]), Number(match[2]), Number(match[3])],
-        pre: match[4]?.split(".") ?? [],
-    }
-}

package/tui.tsx

@@ -1,275 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { Plugin } from "@opencode/plugin/tui"
-import { InputRenderable, type CursorStyleOptions, type KeyEvent } from "@opentui/core"
-import { createEffect, onCleanup } from "solid-js"
-import { applyVimCursorStyle, focusedInput } from "./src/modules/vim/actions"
-import { createVimConfig } from "./src/modules/vim/config"
-import { editInput } from "./src/modules/vim/edit"
-import { keyNotation } from "./src/modules/vim/keys"
-import { createVimLog } from "./src/modules/vim/log"
-import { displayToChar } from "./src/modules/vim/map"
-import { createVimState } from "./src/modules/vim/state"
-import { createVimeeAdapter } from "./src/modules/vim/vimee"
-import { VimStatus } from "./view"
-
-type Context = Parameters<Parameters<typeof Plugin.define>[0]["setup"]>[0]
-
-export default Plugin.define({
-  id: "opencode-vim",
-  setup(context) {
-    context.ui.slot({ append: "app", render: () => <VimHost context={context} /> })
-  },
-})
-
-function VimHost(props: { context: Context }) {
-  const config = createVimConfig(props.context.options)
-  const normalMappings = Object.keys(config.keymaps.normal ?? {})
-  const log = createVimLog(config)
-  const state = createVimState(config.defaultMode, log)
-  const vimee = createVimeeAdapter(state, config, log)
-  const dialogState = createVimState(config.defaultMode, log)
-  const dialogVimee = createVimeeAdapter(dialogState, config, log)
-  const promptVim = { state, vimee }
-  const dialogVim = { state: dialogState, vimee: dialogVimee }
-  let dialogInput: typeof props.context.renderer.currentFocusedEditor = null
-  const [saved, setSaved] = props.context.storage.store("state", { initial: { enabled: true } })
-  const enabled = () => saved.enabled
-  const ctx = createCompatContext(props.context)
-  let cursorMode = ""
-  let cursorInput: typeof props.context.renderer.currentFocusedEditor = null
-  let originalCursorStyle: CursorStyleOptions | undefined
-
-  const removeStatus = props.context.ui.slot({
-    prepend: "prompt.footer",
-    render: (footer) =>
-      footer.mode === "normal" ? (
-        <VimStatus
-          mode={state.mode}
-          enabled={enabled}
-          theme={compatTheme(props.context)}
-        />
-      ) : null,
-  })
-
-  props.context.keymap.layer(() => ({
-    mode: "global",
-    commands: [
-      {
-        id: "opencode-vim.toggle",
-        title: "Toggle Vim Mode",
-        description: "Enable or disable Vim key handling",
-        group: "Vim",
-        palette: true,
-        slash: { name: "vim" },
-        run() {
-          const next = !enabled()
-          void setSaved((draft) => {
-            draft.enabled = next
-          })
-          if (!next) {
-            vimee.suspend()
-            dialogVimee.suspend()
-          }
-          props.context.ui.toast.show({ message: `Vim mode ${next ? "enabled" : "disabled"}`, variant: "info" })
-          props.context.renderer.requestRender()
-        },
-      },
-    ],
-  }))
-
-  const onKey = (event: KeyEvent) => {
-    if (!enabled() || event.defaultPrevented) return
-    const kind = inputKind(props.context)
-    if (!kind) return
-    if (props.context.keymap.pending().length) return
-    const { state, vimee } = kind === "dialog" ? dialogVim : promptVim
-    const key = keyNotation(event as never)
-    if (!key) return
-    const mapped = normalMappings.some((sequence) => sequence.startsWith(key))
-    if (passThroughKey(event, key, state.mode(), vimee.isPending(), mapped)) return
-    if (key === "<Esc>" && state.mode() === "normal" && !vimee.isPending()) return
-
-    if (kind === "dialog" && !vimee.isPending() && !mapped && state.mode() === "normal") {
-      if (key === "<Tab>" || key === "<Home>" || key === "<End>" || key === "<PageUp>" || key === "<PageDown>") return
-      const command = key === "j" ? "dialog.select.next" : key === "k" ? "dialog.select.prev" : undefined
-      if (command && props.context.keymap.commands().some((item) => item.id === command)) {
-        event.preventDefault()
-        event.stopPropagation()
-        props.context.keymap.dispatch(command)
-        return
-      }
-    }
-
-    if (kind === "prompt" && !vimee.isPending() && sendCompletionKey(event, props.context, key, state.mode())) {
-      syncCursor(true)
-      return
-    }
-
-    const before = state.mode()
-    let consumed = false
-    try {
-      consumed = vimee.handle(event as never, key, ctx as never)
-    } finally {
-      if (consumed || state.mode() !== before) {
-        event.preventDefault()
-        event.stopPropagation()
-      }
-    }
-    if (consumed) syncCursor(true)
-  }
-
-  const onFocus = () => {
-    vimee.suspend()
-    dialogVimee.suspend()
-    syncCursor()
-  }
-  props.context.renderer.keyInput.prependListener("keypress", onKey)
-  props.context.renderer.on("focused_editor", onFocus)
-  createEffect(() => syncCursor())
-  onCleanup(() => {
-    removeStatus()
-    props.context.renderer.keyInput.off("keypress", onKey)
-    props.context.renderer.off("focused_editor", onFocus)
-    vimee.cleanup()
-    dialogVimee.cleanup()
-    restoreCursor()
-  })
-
-  return null
-
-  function syncCursor(force = false) {
-    const input = props.context.renderer.currentFocusedEditor
-    const kind = inputKind(props.context)
-    if (!enabled() || !kind || !input) {
-      restoreCursor()
-      return
-    }
-    const { state, vimee } = kind === "dialog" ? dialogVim : promptVim
-    if (kind === "dialog" && dialogInput !== input) {
-      dialogInput = input
-      dialogVimee.suspend()
-      dialogState.setMode(config.defaultMode)
-    }
-    const mode = state.mode()
-    vimee.attach(ctx)
-    const inputChanged = cursorInput !== input
-    if (inputChanged) {
-      restoreCursor()
-      cursorInput = input
-      originalCursorStyle = input.cursorStyle
-    }
-    if (!force && !inputChanged && cursorMode === mode) return
-    if (applyVimCursorStyle(ctx as never, config.cursorStyles[mode])) {
-      cursorMode = mode
-      props.context.renderer.requestRender()
-    }
-  }
-
-  function restoreCursor() {
-    if (cursorInput && !cursorInput.isDestroyed && originalCursorStyle) cursorInput.cursorStyle = originalCursorStyle
-    cursorInput = null
-    cursorMode = ""
-  }
-}
-
-function createCompatContext(context: Context) {
-  const prompt = {
-    get current() {
-      return { input: focusedInputValue(context), mode: "normal", parts: [] }
-    },
-    get focused() {
-      return inputKind(context) !== undefined
-    },
-    set(value: { input: string }) {
-      const input = context.renderer.currentFocusedEditor
-      if (input instanceof InputRenderable) input.value = value.input
-      else if (input) editInput(input, value.input)
-    },
-    submit() {
-      if (inputKind(context) === "dialog") {
-        const command = context.keymap.commands().some((item) => item.id === "dialog.select.submit")
-          ? "dialog.select.submit"
-          : "dialog.prompt.submit"
-        context.keymap.dispatch(command)
-      } else {
-        context.keymap.dispatch("prompt.submit")
-      }
-    },
-    blur() {
-      context.renderer.currentFocusedEditor?.blur()
-    },
-  }
-
-  return {
-    api: {
-      renderer: context.renderer,
-      keymap: {
-        dispatchCommand(command: string) {
-          const ok = context.keymap.commands().some((item) => item.id === command)
-          if (ok) context.keymap.dispatch(command)
-          return { ok }
-        },
-      },
-      theme: { current: compatTheme(context) },
-    },
-    kind: context.ui.router.current().type === "session" ? "session" : "home",
-    prompt: () => (inputKind(context) ? prompt : undefined),
-    requestRender: () => context.renderer.requestRender(),
-  }
-}
-
-function inputKind(context: Context): "prompt" | "dialog" | undefined {
-  if (!context.renderer.currentFocusedEditor) return
-  const commands = context.keymap.commands()
-  if (context.keymap.mode.current() === "modal") {
-    if (commands.some((item) => item.id === "dialog.select.submit" || item.id === "dialog.prompt.submit")) return "dialog"
-    return
-  }
-  if (commands.some(
-    (item) =>
-      item.id === "prompt.submit" || item.id === "prompt.autocomplete.next" || item.id === "prompt.history.previous",
-  )) return "prompt"
-}
-
-function focusedInputValue(context: Context) {
-  return context.renderer.currentFocusedEditor?.plainText ?? ""
-}
-
-function compatTheme(context: Context) {
-  return {
-    get background() { return context.theme.background.base },
-    get info() { return context.theme.text.feedback.info.base },
-    get success() { return context.theme.text.feedback.success.base },
-    get warning() { return context.theme.text.feedback.warning.base },
-    get textMuted() { return context.theme.text.muted },
-  }
-}
-
-function passThroughKey(event: KeyEvent, key: string, mode: string, pending: boolean, mapped: boolean) {
-  if (mode !== "normal") return false
-  if (mapped) return false
-  if (event.ctrl && key !== "<C-r>" && key !== "<C-[>") return true
-  return event.super === true || event.meta === true || (isArrowKey(key) && !pending)
-}
-
-function sendCompletionKey(event: KeyEvent, context: Context, key: string, mode: string) {
-  if (mode !== "normal") return false
-  const command = key === "j" ? "prompt.autocomplete.next" : key === "k" ? "prompt.autocomplete.prev" : undefined
-  if (!command || !isCompletionToken(context) || !context.keymap.commands().some((item) => item.id === command)) return false
-  event.preventDefault()
-  event.stopPropagation()
-  context.keymap.dispatch(command)
-  return true
-}
-
-function isCompletionToken(context: Context) {
-  const input = context.renderer.currentFocusedEditor
-  const text = input?.plainText ?? ""
-  const index = displayToChar(text, Math.max(0, input?.cursorOffset ?? 0))
-  const before = text.slice(0, Math.min(index + 1, text.length))
-  return /^\/\S*$/.test(before) || /(?:^|\s)@\S*$/.test(before)
-}
-
-function isArrowKey(key: string) {
-  return key === "<Left>" || key === "<Down>" || key === "<Up>" || key === "<Right>"
-}