opencode-voice-dictation 0.6.1 → 0.7.0

package/src/gui/settings.tsx

@@ -31,24 +31,57 @@ export function VoiceSettings(props: { speaker: Speaker }) {
   const ttsPrefs = ctx.stores.tts
   const enginePrefs = ctx.stores.engine
   const whisperPrefs = ctx.stores.whisper
+  const whisperCppPrefs = ctx.stores.whispercpp
   const dictation = ctx.main(Dictation)
   const voiceTyping = ctx.main(VoiceTyping)
 
   const [locales, setLocales] = createSignal<readonly string[]>([])
   const [busy, setBusy] = createSignal(false)
   const [whisperBusy, setWhisperBusy] = createSignal(false)
+  const [whisperCppBusy, setWhisperCppBusy] = createSignal(false)
+  const [whisperCppCheckBusy, setWhisperCppCheckBusy] = createSignal(false)
+  const [platform, setPlatform] = createSignal("")
 
   onMount(() => {
     props.speaker.setConfig({ engine: ttsPrefs.value.engine, voice: ttsPrefs.value.voice })
-    void dictation
-      .diagnose()
-      .then((result) => {
-        if (result.locales.length > 0) setLocales(result.locales)
+
+    const loadLocales = () => {
+      void dictation
+        .diagnose()
+        .then((result) => {
+          if (result.locales.length > 0) setLocales(result.locales)
+        })
+        .catch(() => {})
+    }
+
+    void ctx.client
+      .rpc(VoiceRpc)
+      .capabilities({})
+      .then((value) => {
+        const caps = value as { platform: string; engines: string[] }
+        setPlatform(caps.platform)
+        if (!caps.engines.includes(enginePrefs.value.mode) && caps.engines.length > 0) {
+          patchEngine(caps.engines[0] ?? "windows")
+        }
+        if (caps.platform !== "linux") loadLocales()
       })
-      .catch(() => {})
+      .catch(() => loadLocales())
+
     void props.speaker.refreshVoices()
   })
 
+  const engineOptions = () => {
+    if (platform() === "linux") {
+      return [{ value: "whispercpp", label: ctx.t("engine.whispercpp") }]
+    }
+
+    return [
+      { value: "windows", label: ctx.t("engine.windows") },
+      { value: "system", label: ctx.t("engine.system") },
+      { value: "whisper", label: ctx.t("engine.whisper") },
+    ]
+  }
+
   const localeOptions = () => {
     const list = locales()
     const current = prefs.value.locale
@@ -107,6 +140,88 @@ export function VoiceSettings(props: { speaker: Speaker }) {
     })
   }
 
+  const patchWhisperCpp = (change: { model?: string; language?: string }) => {
+    whisperCppPrefs.update((draft) => {
+      if (change.model !== undefined) draft.model = change.model
+      if (change.language !== undefined) draft.language = change.language
+    })
+  }
+
+  const installWhisperCpp = async () => {
+    setWhisperCppBusy(true)
+    try {
+      const result = (await ctx.client.rpc(VoiceRpc).whisperCppInstall({
+        model: whisperCppPrefs.value.model,
+      })) as { ok: boolean; model: string; error: string }
+
+      if (result.ok) {
+        ctx.toast.show({
+          variant: "success",
+          title: ctx.t("pill.title"),
+          description: ctx.t("whispercpp.install.ok", { model: result.model }),
+        })
+      } else {
+        ctx.toast.show({
+          variant: "error",
+          title: ctx.t("pill.title"),
+          description: ctx.t("whispercpp.install.error", { error: result.error || "?" }),
+          persistent: true,
+        })
+      }
+    } catch (cause) {
+      ctx.toast.show({
+        variant: "error",
+        title: ctx.t("pill.title"),
+        description: ctx.t("whispercpp.install.error", {
+          error: cause instanceof Error ? cause.message : String(cause),
+        }),
+        persistent: true,
+      })
+    } finally {
+      setWhisperCppBusy(false)
+    }
+  }
+
+  const checkWhisperCpp = async () => {
+    setWhisperCppCheckBusy(true)
+    try {
+      const status = (await ctx.client.rpc(VoiceRpc).whisperCppStatus({
+        model: whisperCppPrefs.value.model,
+      })) as { installed: boolean; ready: boolean; model: string; error: string }
+
+      if (status.error && !status.installed) {
+        ctx.toast.show({
+          variant: "error",
+          title: ctx.t("pill.title"),
+          description: ctx.t("whispercpp.test.error", { error: status.error }),
+          persistent: true,
+        })
+      } else if (!status.installed) {
+        ctx.toast.show({
+          variant: "default",
+          title: ctx.t("pill.title"),
+          description: ctx.t("whispercpp.test.missing"),
+        })
+      } else {
+        ctx.toast.show({
+          variant: "success",
+          title: ctx.t("pill.title"),
+          description: ctx.t("whispercpp.test.ready", { model: status.model }),
+        })
+      }
+    } catch (cause) {
+      ctx.toast.show({
+        variant: "error",
+        title: ctx.t("pill.title"),
+        description: ctx.t("whispercpp.test.error", {
+          error: cause instanceof Error ? cause.message : String(cause),
+        }),
+      })
+    } finally {
+      setWhisperCppCheckBusy(false)
+    }
+  }
+
   const testWhisper = async () => {
     setWhisperBusy(true)
     try {
@@ -232,11 +347,7 @@ export function VoiceSettings(props: { speaker: Speaker }) {
           <ui.Select
             label={ctx.t("settings.engine")}
             value={enginePrefs.value.mode}
-            options={[
-              { value: "windows", label: ctx.t("engine.windows") },
-              { value: "system", label: ctx.t("engine.system") },
-              { value: "whisper", label: ctx.t("engine.whisper") },
-            ]}
+            options={engineOptions()}
             onChange={(value) => patchEngine(value)}
           />
         </ui.SettingsRow>
@@ -310,6 +421,62 @@ export function VoiceSettings(props: { speaker: Speaker }) {
           </ui.SettingsRow>
         </Show>
 
+        <Show when={enginePrefs.value.mode === "whispercpp"}>
+          <ui.SettingsRow
+            id="whispercpp-model"
+            title={ctx.t("whispercpp.model")}
+            description={ctx.t("whispercpp.model.description")}
+          >
+            <ui.Select
+              label={ctx.t("whispercpp.model")}
+              value={whisperCppPrefs.value.model}
+              options={[
+                { value: "base-q5_1", label: "base-q5_1 · 57 MB" },
+                { value: "small-q5_1", label: "small-q5_1 · 180 MB" },
+              ]}
+              onChange={(value) => patchWhisperCpp({ model: value })}
+            />
+          </ui.SettingsRow>
+
+          <ui.SettingsRow
+            id="whispercpp-language"
+            title={ctx.t("whispercpp.language")}
+            description={ctx.t("whispercpp.language.description")}
+          >
+            <ui.Select
+              label={ctx.t("whispercpp.language")}
+              value={whisperCppPrefs.value.language}
+              options={[
+                { value: "auto", label: ctx.t("whispercpp.language.auto") },
+                { value: "es", label: "Español" },
+                { value: "en", label: "English" },
+                { value: "pt", label: "Português" },
+              ]}
+              onChange={(value) => patchWhisperCpp({ language: value })}
+            />
+          </ui.SettingsRow>
+
+          <ui.SettingsRow
+            id="whispercpp-install"
+            title={ctx.t("whispercpp.install")}
+            description={ctx.t("whispercpp.install.description")}
+          >
+            <ui.Button busy={whisperCppBusy()} onClick={() => void installWhisperCpp()}>
+              {ctx.t("whispercpp.install.run")}
+            </ui.Button>
+          </ui.SettingsRow>
+
+          <ui.SettingsRow
+            id="whispercpp-test"
+            title={ctx.t("whispercpp.test")}
+            description={ctx.t("whispercpp.test.description")}
+          >
+            <ui.Button busy={whisperCppCheckBusy()} onClick={() => void checkWhisperCpp()}>
+              {ctx.t("whispercpp.test.run")}
+            </ui.Button>
+          </ui.SettingsRow>
+        </Show>
+
         <Show when={enginePrefs.value.mode === "system"}>
           <ui.SettingsRow
             id="language"
@@ -439,13 +606,15 @@ export function VoiceSettings(props: { speaker: Speaker }) {
         </ui.SettingsRow>
       </ui.SettingsSection>
 
-      <ui.SettingsSection title={ctx.t("settings.test.section")}>
-        <ui.SettingsRow id="test" title={ctx.t("settings.test")} description={ctx.t("settings.test.description")}>
-          <ui.Button busy={busy()} onClick={() => void test()}>
-            {ctx.t("settings.test.run")}
-          </ui.Button>
-        </ui.SettingsRow>
-      </ui.SettingsSection>
+      <Show when={platform() !== "linux"}>
+        <ui.SettingsSection title={ctx.t("settings.test.section")}>
+          <ui.SettingsRow id="test" title={ctx.t("settings.test")} description={ctx.t("settings.test.description")}>
+            <ui.Button busy={busy()} onClick={() => void test()}>
+              {ctx.t("settings.test.run")}
+            </ui.Button>
+          </ui.SettingsRow>
+        </ui.SettingsSection>
+      </Show>
     </ui.SettingsLayout>
   )
 }

package/src/gui/window.tsx

@@ -56,9 +56,28 @@ export const setup: Plugin.Setup<typeof definition> = (ctx) => {
   const prefs = ctx.stores.prefs
   const engine = ctx.stores.engine
   const whisper = ctx.stores.whisper
+  const whisperCpp = ctx.stores.whispercpp
   const [windowsActive, setWindowsActive] = createSignal(false)
   const [whisperState, setWhisperState] = createSignal<"idle" | "recording" | "transcribing">("idle")
 
+  // The server owns the OS: it decides which engines exist here. On Linux this
+  // switches the default to whisper.cpp and drops the Windows-only engines.
+  void ctx.client
+    .rpc(VoiceRpc)
+    .capabilities({})
+    .then((value) => {
+      const caps = value as { platform: string; engines: string[] }
+      if (!caps.engines.includes(engine.value.mode) && caps.engines.length > 0) {
+        engine.update((draft) => {
+          draft.mode = caps.engines[0] ?? "windows"
+        })
+      }
+    })
+    .catch(() => {})
+
+  const localMode = () =>
+    engine.value.mode === "whisper" || engine.value.mode === "whispercpp" ? engine.value.mode : undefined
+
   let targetSession: string | undefined
   let recording: Recording | undefined
 
@@ -122,7 +141,9 @@ export const setup: Plugin.Setup<typeof definition> = (ctx) => {
       })
   }
 
-  const startWhisper = async () => {
+  const localError = () => ctx.t(localMode() === "whispercpp" ? "error.whispercpp" : "error.whisper")
+
+  const startLocal = async () => {
     if (whisperState() !== "idle") return
     speaker.cancel()
 
@@ -133,19 +154,19 @@ export const setup: Plugin.Setup<typeof definition> = (ctx) => {
       ctx.toast.show({
         variant: "error",
         title: ctx.t("pill.title"),
-        description: cause instanceof Error ? cause.message : ctx.t("error.whisper"),
+        description: cause instanceof Error ? cause.message : localError(),
       })
     }
   }
 
-  const cancelWhisper = () => {
+  const cancelLocal = () => {
     const current = recording
     recording = undefined
     if (current) void current.stop().catch(() => {})
     setWhisperState("idle")
   }
 
-  const stopWhisper = async () => {
+  const stopLocal = async () => {
     const current = recording
     recording = undefined
 
@@ -155,22 +176,34 @@ export const setup: Plugin.Setup<typeof definition> = (ctx) => {
     }
 
     setWhisperState("transcribing")
+    const mode = localMode()
 
     try {
       const blob = await current.stop()
       const audio = await blobToBase64(blob)
-      const result = (await ctx.client.rpc(VoiceRpc).whisperTranscribe({
-        audio,
-        mime: blob.type,
-        language: whisper.value.language,
-        python: whisper.value.python,
-        model: whisper.value.model,
-      })) as { text: string; language: string }
+      const result = (mode === "whispercpp"
+        ? await ctx.client.rpc(VoiceRpc).whisperCppTranscribe({
+            audio,
+            mime: blob.type,
+            language: whisperCpp.value.language,
+            model: whisperCpp.value.model,
+          })
+        : await ctx.client.rpc(VoiceRpc).whisperTranscribe({
+            audio,
+            mime: blob.type,
+            language: whisper.value.language,
+            python: whisper.value.python,
+            model: whisper.value.model,
+          })) as { text: string; language: string }
 
       const text = result.text.trim()
 
       if (!text) {
-        ctx.toast.show({ variant: "default", title: ctx.t("pill.title"), description: ctx.t("whisper.empty") })
+        ctx.toast.show({
+          variant: "default",
+          title: ctx.t("pill.title"),
+          description: ctx.t(mode === "whispercpp" ? "whispercpp.empty" : "whisper.empty"),
+        })
         return
       }
 
@@ -185,7 +218,7 @@ export const setup: Plugin.Setup<typeof definition> = (ctx) => {
       ctx.toast.show({
         variant: "error",
         title: ctx.t("pill.title"),
-        description: cause instanceof Error ? cause.message : ctx.t("error.whisper"),
+        description: cause instanceof Error ? cause.message : localError(),
       })
     } finally {
       setWhisperState("idle")
@@ -193,9 +226,9 @@ export const setup: Plugin.Setup<typeof definition> = (ctx) => {
   }
 
   const toggle = () => {
-    if (engine.value.mode === "whisper") {
-      if (whisperState() === "recording") void stopWhisper()
-      else if (whisperState() === "idle") void startWhisper()
+    if (localMode()) {
+      if (whisperState() === "recording") void stopLocal()
+      else if (whisperState() === "idle") void startLocal()
       return
     }
 
@@ -210,7 +243,7 @@ export const setup: Plugin.Setup<typeof definition> = (ctx) => {
   }
 
   const read = () => {
-    if (whisperState() === "recording") cancelWhisper()
+    if (whisperState() === "recording") cancelLocal()
 
     if (speaker.speaking()) {
       speaker.cancel()
@@ -318,7 +351,9 @@ export const setup: Plugin.Setup<typeof definition> = (ctx) => {
           }
     }
 
-    if (engine.value.mode === "whisper") {
+    if (engine.value.mode === "whisper" || engine.value.mode === "whispercpp") {
+      const title = ctx.t(engine.value.mode === "whispercpp" ? "pill.whispercpp" : "pill.whisper")
+
       if (whisperState() === "recording") {
         return {
           label: ctx.t("pill.recording"),
@@ -333,14 +368,14 @@ export const setup: Plugin.Setup<typeof definition> = (ctx) => {
         return {
           label: ctx.t("pill.transcribing"),
           icon: "outline-audio",
-          title: ctx.t("pill.whisper"),
+          title,
         }
       }
 
       return {
         label: ctx.t("pill.idle"),
         icon: "outline-wave-audio",
-        title: ctx.t("pill.whisper"),
+        title,
         run: toggle,
       }
     }
@@ -464,6 +499,10 @@ export const setup: Plugin.Setup<typeof definition> = (ctx) => {
         { id: "whisper-model", title: ctx.t("whisper.model"), keywords: "whisper model modelo" },
         { id: "whisper-language", title: ctx.t("whisper.language"), keywords: "whisper language idioma" },
         { id: "whisper-test", title: ctx.t("whisper.test"), keywords: "whisper check comprobar" },
+        { id: "whispercpp-model", title: ctx.t("whispercpp.model"), keywords: "whisper.cpp model modelo" },
+        { id: "whispercpp-language", title: ctx.t("whispercpp.language"), keywords: "whisper.cpp language idioma" },
+        { id: "whispercpp-install", title: ctx.t("whispercpp.install"), keywords: "whisper.cpp download descargar instalar" },
+        { id: "whispercpp-test", title: ctx.t("whispercpp.test"), keywords: "whisper.cpp check comprobar" },
         { id: "rate", title: ctx.t("speech.rate"), keywords: "read aloud speed velocidad lectura" },
         { id: "skip-code", title: ctx.t("speech.skipCode"), keywords: "read aloud code codigo lectura" },
         { id: "preview", title: ctx.t("speech.preview"), keywords: "read aloud test voice probar voz" },

package/src/index.ts

@@ -2,20 +2,31 @@ import { Plugin } from "@opencode/plugin"
 import { listEdgeVoices, synthesizeEdge } from "./edge.js"
 import { VoiceRpc } from "./rpc.js"
 import { WhisperEngine } from "./whisper/server.js"
+import { installWhisperCpp, WhisperCppEngine } from "./whispercpp/server.js"
 
 /**
  * Server part of the plugin.
  *
- * It registers the Edge TTS and Whisper RPCs. Running them here (instead of
- * in the Electron main process) lets their dependencies resolve from the
- * plugin's own node_modules.
+ * It registers the Edge TTS, WhisperX and whisper.cpp RPCs. Running them here
+ * (instead of in the Electron main process) lets their dependencies resolve
+ * from the plugin's own node_modules.
  */
 export default Plugin.define({
   id: "voice-dictation",
   async setup(ctx) {
     const whisper = new WhisperEngine()
+    const whisperCpp = new WhisperCppEngine()
 
     await ctx.rpc.register(VoiceRpc, {
+      capabilities: async () => ({
+        platform: process.platform,
+        engines:
+          process.platform === "linux"
+            ? ["whispercpp"]
+            : process.platform === "win32"
+              ? ["windows", "system", "whisper"]
+              : [],
+      }),
       edgeVoices: async () => listEdgeVoices(),
       edgeSpeak: async (input) => {
         const { text, voice, rate } = input as { text: string; voice: string; rate: number }
@@ -42,9 +53,28 @@ export default Plugin.define({
           }
         }
       },
+      whisperCppInstall: async (input) => {
+        const { model } = input as { model: string }
+        return installWhisperCpp(model)
+      },
+      whisperCppStatus: async (input) => {
+        const { model } = input as { model: string }
+        return whisperCpp.status(model)
+      },
+      whisperCppTranscribe: async (input) => {
+        return whisperCpp.transcribe(input as {
+          audio: string
+          mime: string
+          language: string
+          model: string
+        })
+      },
     })
 
-    return () => whisper.stop()
+    return () => {
+      whisper.stop()
+      whisperCpp.stop()
+    }
   },
 })
 

package/src/rpc.ts

@@ -85,6 +85,86 @@ export const VoiceRpc = {
         additionalProperties: false,
       },
     },
+    /**
+     * Tells the window which OS the server runs on and which dictation engines
+     * exist there. The window uses it to pick the default engine and to hide
+     * engines that do not apply (Win+H on Linux, whisper.cpp on Windows).
+     */
+    capabilities: {
+      input: { type: "object", additionalProperties: false },
+      output: {
+        type: "object",
+        properties: {
+          platform: { type: "string" },
+          engines: { type: "array", items: { type: "string" } },
+        },
+        required: ["platform", "engines"],
+        additionalProperties: false,
+      },
+    },
+    whisperCppInstall: {
+      input: {
+        type: "object",
+        properties: {
+          model: { type: "string" },
+        },
+        required: ["model"],
+        additionalProperties: false,
+      },
+      output: {
+        type: "object",
+        properties: {
+          ok: { type: "boolean" },
+          model: { type: "string" },
+          error: { type: "string" },
+        },
+        required: ["ok", "model", "error"],
+        additionalProperties: false,
+      },
+    },
+    whisperCppStatus: {
+      input: {
+        type: "object",
+        properties: {
+          model: { type: "string" },
+        },
+        required: ["model"],
+        additionalProperties: false,
+      },
+      output: {
+        type: "object",
+        properties: {
+          installed: { type: "boolean" },
+          ready: { type: "boolean" },
+          model: { type: "string" },
+          error: { type: "string" },
+        },
+        required: ["installed", "ready", "model", "error"],
+        additionalProperties: false,
+      },
+    },
+    whisperCppTranscribe: {
+      input: {
+        type: "object",
+        properties: {
+          audio: { type: "string" },
+          mime: { type: "string" },
+          language: { type: "string" },
+          model: { type: "string" },
+        },
+        required: ["audio", "mime", "language", "model"],
+        additionalProperties: false,
+      },
+      output: {
+        type: "object",
+        properties: {
+          text: { type: "string" },
+          language: { type: "string" },
+        },
+        required: ["text", "language"],
+        additionalProperties: false,
+      },
+    },
   },
   events: {},
 } as const satisfies Rpc.PortableDefinition