opencode-vim 0.0.2

package/README.md

@@ -0,0 +1,13 @@
+# opencode-vim
+
+Adds Vim-style insert and normal mode editing to the OpenCode prompt.
+
+## Installation
+
+Install from the CLI:
+
+```bash
+opencode plugin opencode-vim@latest --global
+```
+
+See [docs/configuration.md](./docs/configuration.md) for configuration options and keymap examples.

package/bun.lock

@@ -0,0 +1,15 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "opencode-vim",
+      "dependencies": {
+        "@vimee/core": "^0.3.0",
+      },
+    },
+  },
+  "packages": {
+    "@vimee/core": ["@vimee/core@0.3.0", "", {}, "sha512-aC44fw6HhmjrbJMafAk3oUZIDpFbgNebbDsWwMIFD0WwnOUZPETgzU3HYQetmwz0e38JY3I/g8CJXRQjspgJZw=="],
+  }
+}

package/docs/configuration.md

@@ -0,0 +1,403 @@
+# Configuration Guide
+
+This guide shows how to enable `opencode-vim` in OpenCode and configure its Vim prompt behavior.
+
+## Basic Setup
+
+Add `opencode-vim` to the `plugin` array in your OpenCode `tui.jsonc` file:
+
+```jsonc
+{
+  "$schema": "https://opencode.ai/tui.json",
+  "plugin": [
+    [
+      "./plugin/opencode-vim",
+      {
+        "vim": {
+          "defaultMode": "insert"
+        }
+      }
+    ]
+  ]
+}
+```
+
+If your plugin is installed somewhere else, change the plugin path to match your setup.
+
+## Full Example
+
+```jsonc
+{
+  "$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": {
+              "<CR>": "submit",
+              "Y": "y$"
+            }
+          }
+        }
+      }
+    ]
+  ]
+}
+```
+
+## Options
+
+### `defaultMode`
+
+The mode the prompt starts in.
+
+Allowed values:
+
+- `"insert"`
+- `"normal"`
+
+Default:
+
+```jsonc
+"defaultMode": "insert"
+```
+
+Example:
+
+```jsonc
+"defaultMode": "normal"
+```
+
+### `keymapTimeout`
+
+How long, in milliseconds, the prompt waits for the next key when a configured keymap has only been partially typed.
+
+Default:
+
+```jsonc
+"keymapTimeout": 500
+```
+
+Examples:
+
+```jsonc
+"keymapTimeout": 250
+```
+
+```jsonc
+"keymapTimeout": 1000
+```
+
+Use a shorter timeout for faster fallback after partial mappings. Use a longer timeout if you type multi-key mappings slowly.
+
+### `pendingDisplayDelay`
+
+How long, in milliseconds, the prompt waits before showing a pending key sequence in the status area.
+
+Default:
+
+```jsonc
+"pendingDisplayDelay": 120
+```
+
+Examples:
+
+```jsonc
+"pendingDisplayDelay": 0
+```
+
+```jsonc
+"pendingDisplayDelay": 300
+```
+
+This only affects display. It does not change how long keymaps wait for more input.
+
+### `cursorStyles`
+
+The cursor style to use in each mode.
+
+Allowed styles:
+
+- `"block"`
+- `"line"`
+- `"underline"`
+- `"default"`
+
+Default:
+
+```jsonc
+"cursorStyles": {
+  "insert": {
+    "style": "line",
+    "blinking": true
+  },
+  "normal": {
+    "style": "block",
+    "blinking": true
+  }
+}
+```
+
+Examples:
+
+```jsonc
+"cursorStyles": {
+  "insert": {
+    "style": "line",
+    "blinking": false
+  },
+  "normal": {
+    "style": "block",
+    "blinking": false
+  }
+}
+```
+
+```jsonc
+"cursorStyles": {
+  "insert": {
+    "style": "underline"
+  },
+  "normal": {
+    "style": "default"
+  }
+}
+```
+
+You can configure only one mode if you want. Any omitted values use the defaults.
+
+### `debug`
+
+Enables debug logging.
+
+Default:
+
+```jsonc
+"debug": false
+```
+
+Example:
+
+```jsonc
+"debug": true
+```
+
+You can also enable debug logging with this environment variable:
+
+```bash
+VIM_PROMPT_DEBUG=1
+```
+
+### `debugPath`
+
+The file path used for debug logs when debug logging is enabled.
+
+Default:
+
+```txt
+~/.cache/opencode/opencode-vim.log
+```
+
+Example:
+
+```jsonc
+"debugPath": "/tmp/opencode-vim.log"
+```
+
+Use an absolute path in config. `~` is not expanded inside `debugPath`.
+
+### `keymaps`
+
+Custom keymaps for insert mode and normal mode.
+
+Allowed modes:
+
+- `"insert"`
+- `"normal"`
+
+Each keymap entry maps a key sequence to an action:
+
+```jsonc
+"keymaps": {
+  "insert": {
+    "kj": "normal"
+  },
+  "normal": {
+    "<CR>": "submit"
+  }
+}
+```
+
+Supported built-in actions:
+
+- `"normal"` exits insert mode and enters normal mode.
+- `"insert"` enters insert mode.
+- `"submit"` submits the OpenCode prompt.
+
+Any other action string is treated as a Vim key sequence. For example, this maps `Y` to yank from the cursor to the end of the line:
+
+```jsonc
+"keymaps": {
+  "normal": {
+    "Y": "y$"
+  }
+}
+```
+
+## Keymap Syntax
+
+Key sequences can contain printable ASCII characters, except literal spaces. Use `<Space>` for the space key.
+
+Examples:
+
+```jsonc
+"x": "d"
+"gg": "0"
+"Y": "y$"
+"\\r": "<C-r>"
+```
+
+Supported special keys:
+
+- `<Esc>`
+- `<CR>`
+- `<Tab>`
+- `<BS>`
+- `<Del>`
+- `<Space>`
+- `<C-a>` through `<C-z>`
+
+Ctrl key names must be lowercase. Use `<C-s>`, not `<C-S>`.
+
+Unsupported examples:
+
+```jsonc
+"<C-S>": "submit"
+"<C-1>": "submit"
+"<Up>": "k"
+"a b": "normal"
+```
+
+Invalid keymaps are skipped. Enable debug logging if you need to troubleshoot keymap registration.
+
+## Keymap Examples
+
+Use `kj` or `jk` to leave insert mode:
+
+```jsonc
+"keymaps": {
+  "insert": {
+    "kj": "normal",
+    "jk": "normal"
+  }
+}
+```
+
+Submit the prompt with Enter in normal mode:
+
+```jsonc
+"keymaps": {
+  "normal": {
+    "<CR>": "submit"
+  }
+}
+```
+
+Submit the prompt with Ctrl-S in insert mode:
+
+```jsonc
+"keymaps": {
+  "insert": {
+    "<C-s>": "submit"
+  }
+}
+```
+
+Make `Y` yank to the end of the line:
+
+```jsonc
+"keymaps": {
+  "normal": {
+    "Y": "y$"
+  }
+}
+```
+
+Make `D` delete to the beginning of the line:
+
+```jsonc
+"keymaps": {
+  "normal": {
+    "D": "d0"
+  }
+}
+```
+
+Make `H` move to the beginning and `L` move to the end:
+
+```jsonc
+"keymaps": {
+  "normal": {
+    "H": "0",
+    "L": "$"
+  }
+}
+```
+
+Use `q` to enter insert mode from normal mode:
+
+```jsonc
+"keymaps": {
+  "normal": {
+    "q": "insert"
+  }
+}
+```
+
+Use a leader-style sequence:
+
+```jsonc
+"keymaps": {
+  "normal": {
+    "\\s": "submit",
+    "\\r": "<C-r>"
+  }
+}
+```
+
+## Troubleshooting
+
+If a keymap does not work, check these first:
+
+- The mode is either `insert` or `normal`.
+- The key sequence does not contain a literal space.
+- Special keys use one of the supported names exactly.
+- Ctrl keys use lowercase letters, such as `<C-s>`.
+- The action string is not empty.
+
+To debug configuration problems, enable logging:
+
+```jsonc
+"debug": true,
+"debugPath": "/tmp/opencode-vim.log"
+```

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "opencode-vim",
+  "version": "0.0.2",
+  "exports": {
+    "./tui": {
+      "import": "./tui.tsx"
+    }
+  },
+  "dependencies": {
+    "@vimee/core": "^0.3.0"
+  }
+}

package/src/modules/snippets/index.tsx

@@ -0,0 +1,19 @@
+/** @jsxImportSource @opentui/solid */
+import type { PromptModule } from "../../prompt/types"
+import type { SnippetController } from "./types"
+import { SnippetAutocomplete } from "./view"
+
+export function createSnippetsModule(): PromptModule {
+    const controller: SnippetController = {}
+
+    return {
+        id: "snippets",
+        order: -10,
+        onSubmit() {
+            return controller.accept?.() === true
+        },
+        renderAbove(ctx) {
+            return <SnippetAutocomplete ctx={ctx} controller={controller} />
+        },
+    }
+}

package/src/modules/snippets/loader.ts

@@ -0,0 +1,147 @@
+import { basename, join } from "node:path"
+import { mkdir, writeFile } from "node:fs/promises"
+import type { SnippetInfo, SnippetSource } from "./types"
+
+const SNIPPET_EXT = ".md"
+const EMPTY_SNIPPET = `---
+description: ""
+---
+
+`
+
+export async function loadSnippets(projectDir?: string) {
+    const registry = new Map<string, SnippetInfo>()
+    const home = process.env.HOME
+
+    if (home) {
+        await loadDir(registry, join(home, ".config/opencode/snippets"), "global")
+        await loadDir(registry, join(home, ".config/opencode/snippet"), "global")
+    }
+
+    if (projectDir) {
+        await loadDir(registry, join(projectDir, ".opencode/snippets"), "project")
+        await loadDir(registry, join(projectDir, ".opencode/snippet"), "project")
+    }
+
+    return listSnippets(registry).sort((left, right) => sourceRank(left) - sourceRank(right) || left.name.localeCompare(right.name))
+}
+
+async function loadDir(registry: Map<string, SnippetInfo>, dir: string, source: SnippetSource) {
+    let entries: string[]
+    try {
+        entries = await Array.fromAsync(new Bun.Glob(`*${SNIPPET_EXT}`).scan({ cwd: dir, onlyFiles: true }))
+    } catch {
+        return
+    }
+
+    for (const entry of entries) {
+        const snippet = await loadFile(join(dir, entry), source)
+        if (snippet) registerSnippet(registry, snippet)
+    }
+}
+
+async function loadFile(filePath: string, source: SnippetSource) {
+    let raw: string
+    try {
+        raw = await Bun.file(filePath).text()
+    } catch {
+        return undefined
+    }
+
+    const parsed = parseFrontmatter(raw)
+    return {
+        name: basename(filePath, SNIPPET_EXT),
+        content: parsed.content.trim(),
+        aliases: normalizeAliases(parsed.data.aliases ?? parsed.data.alias),
+        description: typeof parsed.data.description === "string" ? parsed.data.description : undefined,
+        filePath,
+        source,
+    } satisfies SnippetInfo
+}
+
+export async function ensureSnippetDraft(name: string, projectDir?: string) {
+    const dir = await ensureSnippetsDir(projectDir)
+    const filePath = join(dir, `${name}${SNIPPET_EXT}`)
+    if (!(await Bun.file(filePath).exists())) await writeFile(filePath, EMPTY_SNIPPET)
+    return filePath
+}
+
+async function ensureSnippetsDir(projectDir?: string) {
+    const home = process.env.HOME
+    const dir = projectDir ? join(projectDir, ".opencode/snippet") : home ? join(home, ".config/opencode/snippet") : undefined
+    if (!dir) throw new Error("Unable to resolve snippets directory")
+    await mkdir(dir, { recursive: true })
+    return dir
+}
+
+export function parseFrontmatter(raw: string) {
+    if (!raw.startsWith("---\n")) return { data: {} as Record<string, unknown>, content: raw }
+
+    const end = raw.indexOf("\n---", 4)
+    if (end < 0) return { data: {} as Record<string, unknown>, content: raw }
+
+    return {
+        data: parseYamlish(raw.slice(4, end)),
+        content: raw.slice(end + 4).replace(/^\r?\n/, ""),
+    }
+}
+
+function parseYamlish(input: string) {
+    const data: Record<string, unknown> = {}
+    const lines = input.split(/\r?\n/)
+    let currentList: string | undefined
+
+    for (const line of lines) {
+        const listItem = /^\s*-\s*(.+)$/.exec(line)
+        if (listItem && currentList) {
+            const value = String(listItem[1]).trim()
+            data[currentList] = [...asArray(data[currentList]), unquote(value)]
+            continue
+        }
+
+        const pair = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line)
+        if (!pair) continue
+
+        currentList = undefined
+        const key = pair[1]
+        const value = pair[2].trim()
+        if (!value) {
+            data[key] = []
+            currentList = key
+        } else {
+            data[key] = unquote(value)
+        }
+    }
+
+    return data
+}
+
+export function normalizeAliases(value: unknown) {
+    return asArray(value).filter((entry) => typeof entry === "string" && entry.length > 0) as string[]
+}
+
+function asArray(value: unknown) {
+    return Array.isArray(value) ? value : typeof value === "string" ? [value] : []
+}
+
+export function unquote(value: string) {
+    return value.replace(/^['"]|['"]$/g, "")
+}
+
+function registerSnippet(registry: Map<string, SnippetInfo>, snippet: SnippetInfo) {
+    const old = registry.get(snippet.name.toLowerCase())
+    if (old) {
+        for (const alias of old.aliases) registry.delete(alias.toLowerCase())
+    }
+
+    registry.set(snippet.name.toLowerCase(), snippet)
+    for (const alias of snippet.aliases) registry.set(alias.toLowerCase(), snippet)
+}
+
+function listSnippets(registry: Map<string, SnippetInfo>) {
+    return [...new Map([...registry.values()].map((snippet) => [snippet.name, snippet])).values()]
+}
+
+function sourceRank(snippet: SnippetInfo) {
+    return snippet.source === "project" ? 0 : 1
+}