opencode-groq-dictate 1.1.6 → 1.1.8

package/README.md

@@ -67,16 +67,42 @@ clone out of `~/.config/opencode/plugins/` before installing from npm.
 | Key | Action |
 |-----|--------|
 | `alt+v` | start recording, press again to stop and transcribe |
+| `ctrl+alt+v` | same, but the prompt is submitted as soon as the text lands |
+| click on `🎤 Groq Dictate` or on the `state` row | same as `alt+v` |
+| `ctrl+click` on the same two | same as `ctrl+alt+v` |
 | `esc` | cancel the take: no upload, no request, no cost |
 | `/dictate` | same as `alt+v`, from the command palette |
+| `⚙` next to the title | open the settings panel |
 
 A take stops on its own after 60 seconds. Everything else is in the palette under
-**Voice**: `Dictation model`, `Dictation language`, `Dictation quota`.
+**Voice**: `Dictate (Groq) and submit`, `Dictation model`, `Dictation language`,
+`Dictation quota`, `Dictation settings`.
+
+The `⚙` panel (or `Dictation settings` in the palette) holds the four things worth
+changing: the two shortcuts, the model and the language. Click a row, write the new
+value, and it applies at once — the keymap layer reads the stored config, so a new
+combination works without restarting OpenCode. A blank shortcut disables the key but
+leaves the command in the palette. `model` and `language` open the same pickers as the
+palette commands.
+
+The shortcuts are ordinary commands, so you can also rebind or disable them in
+`cli.json` without touching the plugin:
+
+```jsonc
+{
+  "keybinds": {
+    "opencode-groq-dictate.toggle": "alt+d",
+    "opencode-groq-dictate.toggleSubmit": false
+  }
+}
+```
+
+The click handlers stay available even when both bindings are off.
 
 Super+V cannot be used: VTE (Tilix, xfce4-terminal) only enables xterm
 `modifyOtherKeys`, which never reports the Super modifier, so the binding could not
-fire inside the terminal. `alt+v` is reported by both the legacy and the
-`modifyOtherKeys` encodings.
+fire inside the terminal. `alt+v` and `ctrl+alt+v` are reported by both the legacy
+and the `modifyOtherKeys` encodings.
 
 ## Screenshots
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-groq-dictate",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "Groq dictation in the OpenCode v2 TUI: alt+v records, transcribes with whisper-large-v3-turbo, and pastes the text into the prompt.",
   "private": false,
   "type": "module",

package/src/voice.test.ts

@@ -2,6 +2,7 @@ import { expect, test } from "bun:test"
 import {
   DEFAULT_MODEL,
   audioSeconds,
+  bindOf,
   cost,
   logLine,
   parseConfig,
@@ -32,19 +33,43 @@ test("the rpm window drops stamps older than a minute", () => {
 })
 
 test("a config with the wrong types falls back to the defaults", () => {
-  expect(parseConfig(null)).toEqual({ apiKey: "", language: "it", model: DEFAULT_MODEL })
+  expect(parseConfig(null)).toEqual({
+    apiKey: "",
+    language: "it",
+    model: DEFAULT_MODEL,
+    bindStart: "alt+v",
+    bindSubmit: "ctrl+alt+v",
+  })
   expect(parseConfig({ apiKey: 42, language: "", model: "nope" })).toEqual({
     apiKey: "",
     language: "it",
     model: DEFAULT_MODEL,
+    bindStart: "alt+v",
+    bindSubmit: "ctrl+alt+v",
   })
-  expect(parseConfig({ apiKey: "gsk_x", language: "auto", model: "whisper-large-v3" })).toEqual({
+  expect(
+    parseConfig({
+      apiKey: "gsk_x",
+      language: "auto",
+      model: "whisper-large-v3",
+      bindStart: "alt+d",
+      bindSubmit: "",
+    }),
+  ).toEqual({
     apiKey: "gsk_x",
     language: "auto",
     model: "whisper-large-v3",
+    bindStart: "alt+d",
+    // An empty bind is meaningful: the command stays in the palette, the key goes away.
+    bindSubmit: "",
   })
 })
 
+test("an empty bind becomes false for the keymap", () => {
+  expect(bindOf("alt+v")).toBe("alt+v")
+  expect(bindOf("  ")).toBe(false)
+})
+
 test("the cost line keeps the shell script's four columns", () => {
   expect(logLine(new Date(2026, 9, 19, 8, 5, 3), 12.34, 0.000137)).toBe("2026-10-19 08:05:03 12.3 0.000137")
   expect(logLine(new Date(2026, 9, 19, 8, 5, 3), 12.34, 0.000137, "whisper-large-v3")).toBe(

package/src/voice.ts

@@ -20,20 +20,43 @@ export const BYTES_PER_SAMPLE = 2
 // parec writes a canonical 44-byte header; anything past it is audio.
 export const WAV_HEADER = 44
 
-export type Config = { apiKey: string; language: string; model: Model }
+export type Config = {
+  apiKey: string
+  language: string
+  model: Model
+  // Empty means "no binding": the command stays in the palette, the key does nothing.
+  bindStart: string
+  bindSubmit: string
+}
 
-export const DEFAULTS: Config = { apiKey: "", language: "it", model: DEFAULT_MODEL }
+export const DEFAULTS: Config = {
+  apiKey: "",
+  language: "it",
+  model: DEFAULT_MODEL,
+  bindStart: "alt+v",
+  bindSubmit: "ctrl+alt+v",
+}
 
 export function parseConfig(raw: unknown): Config {
   const value = (raw ?? {}) as Record<string, unknown>
   const model = MODELS.includes(value.model as Model) ? (value.model as Model) : DEFAULTS.model
+  // Binds are free text: an empty string is meaningful (disabled), a missing key is not.
+  const bind = (key: "bindStart" | "bindSubmit") =>
+    typeof value[key] === "string" ? (value[key] as string) : DEFAULTS[key]
   return {
     apiKey: typeof value.apiKey === "string" ? value.apiKey : DEFAULTS.apiKey,
     language: typeof value.language === "string" && value.language ? value.language : DEFAULTS.language,
     model,
+    bindStart: bind("bindStart"),
+    bindSubmit: bind("bindSubmit"),
   }
 }
 
+// The keymap wants `false` to disable a binding, not an empty string.
+export function bindOf(value: string): string | false {
+  return value.trim() || false
+}
+
 export function audioSeconds(bytes: number): number {
   return Math.max(0, bytes - WAV_HEADER) / (SAMPLE_RATE * BYTES_PER_SAMPLE)
 }

package/tui.tsx

@@ -11,6 +11,7 @@ import {
   MODELS,
   RPM_LIMIT,
   audioSeconds,
+  bindOf,
   cost,
   logLine,
   parseConfig,
@@ -136,7 +137,11 @@ export default Plugin.define({
       return usd
     }
 
-    async function transcribe(seconds: number) {
+    // A recording started with ctrl+alt+v (or ctrl+click) also submits the prompt
+    // once the text lands, so the same gesture can send without reaching for Enter.
+    let submitOnStop = false
+
+    async function transcribe(seconds: number, submit: boolean) {
       const { apiKey, language, model } = settings()
       const key = apiKey || (await askKey())
       if (!key) return
@@ -152,6 +157,12 @@ export default Plugin.define({
       }
 
       await paste(outcome.text)
+      if (submit) {
+        // The TUI applies the paste on the next frame; submitting in the same
+        // tick would send the prompt without the dictated text.
+        await new Promise((done) => setTimeout(done, 80))
+        context.keymap.dispatch("prompt.submit")
+      }
       // The recording is only needed until Groq answers; leaving it in /tmp keeps
       // a copy of everything dictated on disk.
       await rm(WAV, { force: true }).catch(() => {})
@@ -162,6 +173,8 @@ export default Plugin.define({
 
     async function stop() {
       if (!recorder) return
+      const submit = submitOnStop
+      submitOnStop = false
       const child = recorder
       recorder = null
       setRecording(false)
@@ -180,7 +193,7 @@ export default Plugin.define({
       }
       context.ui.toast.show({ message: "Transcribing…", variant: "info" })
       try {
-        await transcribe(seconds)
+        await transcribe(seconds, submit)
       } catch (error) {
         context.ui.toast.show({ message: String(error), variant: "error" })
       } finally {
@@ -197,7 +210,7 @@ export default Plugin.define({
         )
       })
 
-    async function start() {
+    async function start(submit = false) {
       const { apiKey } = settings()
       if (!apiKey) {
         context.ui.toast.show({ message: "Set the Groq API key first", variant: "warning" })
@@ -232,6 +245,9 @@ export default Plugin.define({
         context.ui.toast.show({ message: `parec: ${error.message}`, variant: "error" })
       })
       setRecording(true)
+      // Only a take that actually started arms the submit, so a failed start does
+      // not make the next alt+v send the prompt.
+      submitOnStop = submit
       setElapsed(0)
       ticker = startTicker(() => setElapsed((value) => value + 1))
       // Nobody wants a ten-minute upload because the stop key was forgotten.
@@ -239,13 +255,20 @@ export default Plugin.define({
         context.ui.toast.show({ message: `Stopped at ${MAX_SECONDS}s`, variant: "warning" })
         void stop()
       }, MAX_SECONDS * 1000)
-      context.ui.toast.show({ message: "Recording… alt+v stop · esc cancel", variant: "info", duration: 2000 })
+      context.ui.toast.show({
+        message: submit
+          ? `Recording… ${settings().bindSubmit || "the palette"} stops and sends · esc cancels`
+          : `Recording… ${settings().bindStart || "the palette"} stops · esc cancels`,
+        variant: "info",
+        duration: 2000,
+      })
     }
 
 
     // Esc aborts the take: nothing is uploaded, so no quota and no cost.
     async function cancel() {
       if (!recorder) return
+      submitOnStop = false
       const child = recorder
       recorder = null
       setRecording(false)
@@ -261,8 +284,11 @@ export default Plugin.define({
     }
 
     // One entry point for the keybinding and for the click on the panel.
-
-    const toggle = () => (recording() ? stop() : start())
+    // submit=true means "record, transcribe, then press Enter".
+    const toggle = (submit = false) => {
+      if (recording()) return stop()
+      return start(submit)
+    }
 
     async function pickModel() {
       const model = await context.ui.dialog.select({
@@ -305,6 +331,57 @@ export default Plugin.define({
       context.ui.toast.show({ message: `Language: ${settings().language}`, variant: "success" })
     }
 
+    // One panel for the four things a user changes: the two shortcuts, the model
+    // and the language. Each row reopens the panel after writing, because the
+    // dialog body renders once and its labels would otherwise stay stale.
+    const settingsRow = (label: string, value: string, onClick: () => void) => (
+      <box flexDirection="row" onMouseUp={onClick}>
+        <text>{(label + "  ").padEnd(18)}</text>
+        <text fg={accent()}>{value}</text>
+      </box>
+    )
+
+    function openSettings() {
+      const current = settings()
+      context.ui.dialog.clear()
+      context.ui.dialog.show(() => (
+        <box flexDirection="column" paddingLeft={1} paddingRight={1}>
+          <text fg={accent()}>{"Groq dictation"}</text>
+          <text fg={muted()}>{"click a row: changes apply at once"}</text>
+          {settingsRow("start / stop", current.bindStart || "disabled", () =>
+            editBind("bindStart", "Start and stop"),
+          )}
+          {settingsRow("start and send", current.bindSubmit || "disabled", () =>
+            editBind("bindSubmit", "Start, stop and send"),
+          )}
+          {settingsRow("model", current.model.replace("whisper-", ""), () => change(pickModel))}
+          {settingsRow("language", current.language, () => change(pickLanguage))}
+        </box>
+      ))
+      context.ui.dialog.set({ size: "large", centered: true })
+    }
+
+    // The panel closes before a prompt can open, then comes back with the new value.
+    async function change(action: () => Promise<void>) {
+      context.ui.dialog.clear()
+      await action()
+      openSettings()
+    }
+
+    async function editBind(key: "bindStart" | "bindSubmit", title: string) {
+      context.ui.dialog.clear()
+      const value = await context.ui.dialog.prompt({
+        title: `${title} (blank disables the key)`,
+        placeholder: settings()[key] || "e.g. alt+v",
+        value: settings()[key],
+      })
+      if (value !== undefined)
+        await updateConfig((draft) => {
+          draft[key] = value.trim()
+        })
+      openSettings()
+    }
+
     context.keymap.layer(() => ({
       mode: "global",
       priority: 10,
@@ -315,10 +392,21 @@ export default Plugin.define({
           group: "Voice",
           // Not super+v: VTE only enables xterm modifyOtherKeys, which never
           // reports the Super modifier, so that binding could not fire here.
-          bind: "alt+v",
+          // Read from the stored config, so changing it in the panel rebinds now.
+          bind: bindOf(settings().bindStart),
           palette: true,
           slash: { name: "dictate" },
-          run: toggle,
+          run: () => toggle(),
+        },
+        {
+          id: "opencode-groq-dictate.toggleSubmit",
+          title: "Dictate (Groq) and submit",
+          group: "Voice",
+          // ctrl+alt is what modifyOtherKeys reports, the same path the TUI's own
+          // ctrl+alt defaults take. Rebind or disable it in cli.json like any other.
+          bind: bindOf(settings().bindSubmit),
+          palette: true,
+          run: () => toggle(true),
         },
         {
           id: "opencode-groq-dictate.cancel",
@@ -353,8 +441,19 @@ export default Plugin.define({
           palette: true,
           run: pickModel,
         },
+        {
+          id: "opencode-groq-dictate.settings",
+          title: "Dictation settings",
+          group: "Voice",
+          palette: true,
+          run: openSettings,
+        },
+      ],
+      bindings: [
+        "opencode-groq-dictate.toggle",
+        "opencode-groq-dictate.toggleSubmit",
+        "opencode-groq-dictate.cancel",
       ],
-      bindings: ["opencode-groq-dictate.toggle", "opencode-groq-dictate.cancel"],
     }))
 
     const red = () => context.theme?.hue?.red?.["400"] ?? "#ff5555"
@@ -380,7 +479,15 @@ export default Plugin.define({
 
     // Label column, the same width trick the go-meter rows use so the figures line
     // up under each other instead of drifting.
-    const row = (label: string, value: string, fg: () => string | undefined, onClick?: () => void) => (
+    // ctrl+click mirrors ctrl+alt+v: the OpenTUI MouseEvent carries the modifiers.
+    type Click = { modifiers?: { ctrl?: boolean } } | undefined
+    const wantsSubmit = (event: Click) => !!event?.modifiers?.ctrl
+    const row = (
+      label: string,
+      value: string,
+      fg: () => string | undefined,
+      onClick?: (event: Click) => void,
+    ) => (
       <box flexDirection="row" gap={0} onMouseUp={onClick}>
         <text>{label.padEnd(LABEL_WIDTH)}</text>
         <text fg={fg()}>{value}</text>
@@ -403,14 +510,19 @@ export default Plugin.define({
         const state = () => (recording() ? red() : busy() ? amber() : green())
         return (
           <box flexDirection="column">
-            <text fg={muted()} onMouseUp={toggle}>
-              Groq Dictate
-            </text>
+            <box flexDirection="row" gap={1}>
+              <text fg={muted()} onMouseUp={(event) => toggle(wantsSubmit(event))}>
+                {"🎤 Groq Dictate"}
+              </text>
+              <text fg={muted()} onMouseUp={() => openSettings()}>
+                {"⚙"}
+              </text>
+            </box>
             {row(
               "state",
               recording() ? `● rec ${elapsed()}s` : busy() ? "transcribing…" : "idle",
               state,
-              toggle,
+              (event) => toggle(wantsSubmit(event)),
             )}
             {row("model", settings().model.replace("whisper-", ""), () => undefined, pickModel)}
             {row("lang", settings().language, () => undefined, pickLanguage)}