opencode-voice-dictation 0.0.0-stage → 0.1.0

package/src/gui/engines/system-speech.ts

@@ -0,0 +1,202 @@
+import { spawn, type ChildProcess } from "node:child_process"
+import { createHash } from "node:crypto"
+import { mkdirSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import type { DiagnoseResult } from "../contract"
+import { DICTATION_SCRIPT } from "./script"
+
+export interface EngineOptions {
+  locale: string
+  minConfidence: number
+}
+
+export interface EngineCallbacks {
+  onReady(locale: string): void
+  onFinal(text: string, confidence: number): void
+  onError(code: string, detail: string, available: string[]): void
+  onExit(code: number | null, detail: string): void
+}
+
+export interface EngineHandle {
+  stop(): void
+}
+
+interface EngineEvent {
+  type?: string
+  locale?: string
+  text?: string
+  confidence?: number
+  code?: string
+  detail?: string
+  available?: string[]
+}
+
+const POWERSHELL = "powershell.exe"
+
+function scriptFile(): string {
+  const dir = join(tmpdir(), "opencode-voice-dictation")
+  mkdirSync(dir, { recursive: true })
+  const hash = createHash("sha1").update(DICTATION_SCRIPT).digest("hex").slice(0, 12)
+  const file = join(dir, `dictation-${hash}.ps1`)
+  writeFileSync(file, DICTATION_SCRIPT, "utf8")
+  return file
+}
+
+function spawnPowershell(args: string[]): ChildProcess {
+  return spawn(POWERSHELL, args, {
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "pipe"],
+  })
+}
+
+function killTree(child: ChildProcess) {
+  const pid = child.pid
+  if (pid === undefined) {
+    child.kill()
+    return
+  }
+  const killer = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
+    windowsHide: true,
+    stdio: "ignore",
+  })
+  killer.on("error", () => child.kill())
+}
+
+export function startEngine(options: EngineOptions, callbacks: EngineCallbacks): EngineHandle {
+  const child = spawnPowershell([
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-File",
+    scriptFile(),
+    "-Culture",
+    options.locale,
+    "-MinConfidence",
+    String(options.minConfidence),
+  ])
+
+  let stopped = false
+  let stderr = ""
+  let buffer = ""
+
+  const emit = (event: EngineEvent) => {
+    switch (event.type) {
+      case "ready":
+        callbacks.onReady(event.locale ?? options.locale)
+        break
+      case "final":
+        if (event.text) callbacks.onFinal(event.text, event.confidence ?? 0)
+        break
+      case "error":
+        callbacks.onError(event.code ?? "UNKNOWN", event.detail ?? "", event.available ?? [])
+        break
+    }
+  }
+
+  child.stdout?.setEncoding("utf8")
+  child.stdout?.on("data", (chunk: string) => {
+    buffer += chunk
+    let index = buffer.indexOf("\n")
+    while (index >= 0) {
+      const line = buffer.slice(0, index).replace(/\r$/, "").trim()
+      buffer = buffer.slice(index + 1)
+      if (line) {
+        try {
+          emit(JSON.parse(line) as EngineEvent)
+        } catch {
+          // A partial or unexpected line: ignore it and keep the stream alive.
+        }
+      }
+      index = buffer.indexOf("\n")
+    }
+  })
+
+  child.stderr?.setEncoding("utf8")
+  child.stderr?.on("data", (chunk: string) => {
+    stderr = (stderr + chunk).slice(-2000)
+  })
+
+  child.on("error", (cause) => {
+    if (stopped) return
+    callbacks.onError("ENGINE_START_FAILED", cause.message, [])
+  })
+
+  child.on("close", (code) => {
+    if (stopped) return
+    callbacks.onExit(code, stderr.trim().slice(-500))
+  })
+
+  return {
+    stop() {
+      stopped = true
+      killTree(child)
+    },
+  }
+}
+
+export function diagnose(): Promise<DiagnoseResult> {
+  return new Promise((resolve, reject) => {
+    const child = spawnPowershell([
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      scriptFile(),
+      "-Diagnose",
+    ])
+
+    let stdout = ""
+    let stderr = ""
+    let settled = false
+
+    const finish = (error: Error | undefined, value?: DiagnoseResult) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      if (error) reject(error)
+      else resolve(value as DiagnoseResult)
+    }
+
+    const timer = setTimeout(() => {
+      killTree(child)
+      finish(new Error("diagnose timed out"))
+    }, 20000)
+
+    child.stdout?.setEncoding("utf8")
+    child.stdout?.on("data", (chunk: string) => {
+      stdout += chunk
+    })
+    child.stderr?.setEncoding("utf8")
+    child.stderr?.on("data", (chunk: string) => {
+      stderr += chunk
+    })
+    child.on("error", (cause) => finish(cause))
+    child.on("close", () => {
+      const line = stdout
+        .split(/\r?\n/)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.startsWith("{"))
+        .at(-1)
+
+      if (!line) {
+        finish(new Error(stderr.trim() || "no output from PowerShell"))
+        return
+      }
+
+      try {
+        const parsed = JSON.parse(line) as DiagnoseResult
+        finish(undefined, {
+          locales: parsed.locales ?? [],
+          microphone: parsed.microphone === true,
+          selected: parsed.selected ?? "",
+          error: parsed.error ?? "",
+        })
+      } catch (cause) {
+        finish(cause instanceof Error ? cause : new Error(String(cause)))
+      }
+    })
+  })
+}

package/src/gui/main.ts

@@ -0,0 +1,143 @@
+import type { Plugin } from "@opencode/plugin/gui"
+import { Dictation, Speech } from "./contract"
+import { diagnose, startEngine, type EngineHandle } from "./engines/system-speech"
+import { listSapiVoices, speakSapi, type SpeakHandle } from "./engines/sapi-speech"
+
+type Status = "idle" | "starting" | "listening" | "error"
+
+/**
+ * Runs once in the Electron main process.
+ *
+ * One dictation runs at a time (there is one microphone); the window that
+ * starts it receives the transcript events.
+ */
+export const main: Plugin.MainSetup = (ctx) => {
+  let status: Status = "idle"
+  let error = ""
+  let locale = ""
+  let handle: EngineHandle | undefined
+  let stopping = false
+
+  const reset = () => {
+    handle = undefined
+    stopping = false
+  }
+
+  const dictation = ctx.provide(Dictation, {
+    state: () => ({ status, error, locale }),
+
+    start(input, caller) {
+      if (handle) {
+        stopping = true
+        handle.stop()
+        reset()
+      }
+
+      status = "starting"
+      error = ""
+      locale = input.locale
+      dictation.changed()
+
+      const target = caller.window
+
+      try {
+        handle = startEngine(
+          { locale: input.locale, minConfidence: input.minConfidence },
+          {
+            onReady(selected) {
+              status = "listening"
+              locale = selected
+              dictation.changed()
+            },
+            onFinal(text, confidence) {
+              dictation.emit("final", { text, confidence }, target)
+            },
+            onError(code, detail, available) {
+              status = "error"
+              error = code
+              dictation.changed()
+              dictation.emit("error", { code, detail, available }, target)
+            },
+            onExit(code, detail) {
+              if (stopping) {
+                reset()
+                status = "idle"
+                error = ""
+                locale = ""
+                dictation.changed()
+                return
+              }
+
+              reset()
+              if (status !== "error") {
+                status = "error"
+                error = code === null ? "ENGINE_EXIT" : `ENGINE_EXIT_${code}`
+                dictation.changed()
+                dictation.emit(
+                  "error",
+                  { code: "ENGINE_EXIT", detail: detail || (code === null ? "" : String(code)), available: [] },
+                  target,
+                )
+              }
+            },
+          },
+        )
+      } catch (cause) {
+        status = "error"
+        error = "ENGINE_START_FAILED"
+        dictation.changed()
+        throw cause
+      }
+    },
+
+    stop() {
+      if (handle) {
+        stopping = true
+        handle.stop()
+        reset()
+      }
+      status = "idle"
+      error = ""
+      locale = ""
+      dictation.changed()
+    },
+
+    diagnose() {
+      return diagnose()
+    },
+  })
+
+  let talking: SpeakHandle | undefined
+
+  const speech = ctx.provide(Speech, {
+    speak(input) {
+      talking?.stop()
+      talking = speakSapi(input, (ok) => {
+        talking = undefined
+        speech.emit("done", { ok })
+      })
+    },
+
+    stop() {
+      if (talking) {
+        talking.stop()
+        talking = undefined
+      }
+      speech.emit("done", { ok: true })
+    },
+
+    voices() {
+      return listSapiVoices()
+    },
+  })
+
+  ctx.onCleanup(() => {
+    if (handle) {
+      stopping = true
+      handle.stop()
+      reset()
+    }
+    talking?.stop()
+    talking = undefined
+  })
+}

package/src/gui/settings.tsx

@@ -0,0 +1,244 @@
+import { createSignal, onMount } from "solid-js"
+import { usePlugin } from "@opencode/plugin/gui"
+import { Dictation } from "./contract"
+import type { definition } from "./definition"
+import type { Speaker } from "./speak"
+
+const FALLBACK_LOCALES = [
+  "es-ES",
+  "es-MX",
+  "es-AR",
+  "es-CO",
+  "pt-BR",
+  "pt-PT",
+  "en-US",
+  "en-GB",
+  "fr-FR",
+  "de-DE",
+  "it-IT",
+]
+
+/**
+ * Settings page. It only reads and writes the declared store; the engine is
+ * asked for installed languages when the page mounts.
+ */
+export function VoiceSettings(props: { speaker: Speaker }) {
+  const ctx = usePlugin<typeof definition>()
+  const ui = ctx.ui
+  const prefs = ctx.stores.prefs
+  const speechPrefs = ctx.stores.speech
+  const dictation = ctx.main(Dictation)
+
+  const [locales, setLocales] = createSignal<readonly string[]>([])
+  const [busy, setBusy] = createSignal(false)
+
+  onMount(() => {
+    void dictation
+      .diagnose()
+      .then((result) => {
+        if (result.locales.length > 0) setLocales(result.locales)
+      })
+      .catch(() => {})
+    void props.speaker.refreshVoices()
+  })
+
+  const localeOptions = () => {
+    const list = locales()
+    const current = prefs.value.locale
+    const merged = list.includes(current) ? list : [current, ...list]
+    return merged.map((value) => ({ value, label: value }))
+  }
+
+  const voiceOptions = () => [
+    { value: "", label: ctx.t("speech.voice.auto") },
+    ...props.speaker.voices().map((voice) => ({ value: voice.id, label: voice.label })),
+  ]
+
+  const patch = (change: { locale?: string; minConfidence?: number; trailingSpace?: boolean; autoFocus?: boolean }) => {
+    prefs.update((draft) => {
+      if (change.locale !== undefined) draft.locale = change.locale
+      if (change.minConfidence !== undefined) draft.minConfidence = change.minConfidence
+      if (change.trailingSpace !== undefined) draft.trailingSpace = change.trailingSpace
+      if (change.autoFocus !== undefined) draft.autoFocus = change.autoFocus
+    })
+  }
+
+  const patchSpeech = (change: { voiceURI?: string; rate?: number; skipCode?: boolean }) => {
+    speechPrefs.update((draft) => {
+      if (change.voiceURI !== undefined) draft.voiceURI = change.voiceURI
+      if (change.rate !== undefined) draft.rate = change.rate
+      if (change.skipCode !== undefined) draft.skipCode = change.skipCode
+    })
+  }
+
+  const preview = async () => {
+    try {
+      await props.speaker.preview()
+    } catch (cause) {
+      ctx.toast.show({
+        variant: "error",
+        title: ctx.t("read.title"),
+        description: cause instanceof Error ? cause.message : ctx.t("read.error"),
+      })
+    }
+  }
+
+  const test = async () => {
+    setBusy(true)
+    try {
+      const result = await dictation.diagnose()
+
+      if (result.locales.length === 0) {
+        ctx.toast.show({
+          variant: "error",
+          title: ctx.t("error.title"),
+          description: ctx.t("settings.test.failed", { reason: ctx.t("common.reason.no-recognizers") }),
+          persistent: true,
+        })
+        return
+      }
+
+      if (!result.microphone) {
+        ctx.toast.show({
+          variant: "error",
+          title: ctx.t("error.title"),
+          description: ctx.t("settings.test.failed", { reason: ctx.t("common.reason.no-microphone") }),
+          persistent: true,
+        })
+        return
+      }
+
+      if (result.locales.length > 0 && !locales().length) setLocales(result.locales)
+
+      ctx.toast.show({
+        variant: "success",
+        title: ctx.t("error.title"),
+        description: ctx.t("settings.test.success", { locale: result.selected || result.locales[0] || prefs.value.locale }),
+      })
+    } catch (cause) {
+      ctx.toast.show({
+        variant: "error",
+        title: ctx.t("error.title"),
+        description: cause instanceof Error ? cause.message : String(cause),
+      })
+    } finally {
+      setBusy(false)
+    }
+  }
+
+  return (
+    <ui.SettingsLayout title={ctx.t("settings.title")} description={ctx.t("settings.description")}>
+      <ui.SettingsSection title={ctx.t("settings.section")}>
+        <ui.SettingsRow
+          id="language"
+          title={ctx.t("settings.language")}
+          description={ctx.t("settings.language.description")}
+        >
+          <ui.Select
+            label={ctx.t("settings.language")}
+            value={prefs.value.locale}
+            options={localeOptions().length > 0 ? localeOptions() : FALLBACK_LOCALES.map((value) => ({ value, label: value }))}
+            onChange={(value) => patch({ locale: value })}
+          />
+        </ui.SettingsRow>
+
+        <ui.SettingsRow
+          id="confidence"
+          title={ctx.t("settings.confidence")}
+          description={ctx.t("settings.confidence.description")}
+        >
+          <ui.Select
+            label={ctx.t("settings.confidence")}
+            value={String(prefs.value.minConfidence)}
+            options={[
+              { value: "0.2", label: ctx.t("confidence.low") },
+              { value: "0.4", label: ctx.t("confidence.normal") },
+              { value: "0.6", label: ctx.t("confidence.high") },
+            ]}
+            onChange={(value) => patch({ minConfidence: Number(value) || 0.4 })}
+          />
+        </ui.SettingsRow>
+
+        <ui.SettingsRow id="space" title={ctx.t("settings.space")} description={ctx.t("settings.space.description")}>
+          <ui.Switch
+            label={ctx.t("settings.space")}
+            hideLabel
+            checked={prefs.value.trailingSpace}
+            onChange={(checked) => patch({ trailingSpace: checked })}
+          />
+        </ui.SettingsRow>
+
+        <ui.SettingsRow id="focus" title={ctx.t("settings.focus")} description={ctx.t("settings.focus.description")}>
+          <ui.Switch
+            label={ctx.t("settings.focus")}
+            hideLabel
+            checked={prefs.value.autoFocus}
+            onChange={(checked) => patch({ autoFocus: checked })}
+          />
+        </ui.SettingsRow>
+      </ui.SettingsSection>
+
+      <ui.SettingsSection title={ctx.t("speech.section")}>
+        <ui.SettingsRow
+          id="voice"
+          title={ctx.t("speech.voice")}
+          description={ctx.t("speech.voice.description")}
+        >
+          <ui.Select
+            label={ctx.t("speech.voice")}
+            value={speechPrefs.value.voiceURI}
+            options={voiceOptions()}
+            onChange={(value) => patchSpeech({ voiceURI: value })}
+          />
+        </ui.SettingsRow>
+
+        <ui.SettingsRow
+          id="rate"
+          title={ctx.t("speech.rate")}
+          description={ctx.t("speech.rate.description")}
+        >
+          <ui.Select
+            label={ctx.t("speech.rate")}
+            value={String(speechPrefs.value.rate)}
+            options={[
+              { value: "0.8", label: ctx.t("speech.rate.slow") },
+              { value: "1", label: ctx.t("speech.rate.normal") },
+              { value: "1.2", label: ctx.t("speech.rate.fast") },
+              { value: "1.5", label: ctx.t("speech.rate.faster") },
+            ]}
+            onChange={(value) => patchSpeech({ rate: Number(value) || 1 })}
+          />
+        </ui.SettingsRow>
+
+        <ui.SettingsRow
+          id="skip-code"
+          title={ctx.t("speech.skipCode")}
+          description={ctx.t("speech.skipCode.description")}
+        >
+          <ui.Switch
+            label={ctx.t("speech.skipCode")}
+            hideLabel
+            checked={speechPrefs.value.skipCode}
+            onChange={(checked) => patchSpeech({ skipCode: checked })}
+          />
+        </ui.SettingsRow>
+
+        <ui.SettingsRow
+          id="preview"
+          title={ctx.t("speech.preview")}
+          description={ctx.t("speech.preview.description")}
+        >
+          <ui.Button onClick={() => void preview()}>{ctx.t("read.idle")}</ui.Button>
+        </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>
+    </ui.SettingsLayout>
+  )
+}