opencode-voice-dictation 0.0.0-stage → 0.2.0

package/src/gui/contract.ts

@@ -0,0 +1,87 @@
+import { Schema } from "effect"
+import { Ipc } from "@opencode/plugin/gui"
+
+/**
+ * Bridge between the window setup and the Electron main process.
+ *
+ * The engine lives in `main` because it needs `node:child_process`; the window
+ * only paints status and inserts the transcript.
+ */
+export const Dictation = Ipc.define({
+  id: "voice-dictation.dictation",
+  state: Schema.Struct({
+    status: Schema.Literals(["idle", "starting", "listening", "error"]),
+    error: Schema.String,
+    locale: Schema.String,
+  }),
+  methods: {
+    start: {
+      input: Schema.Struct({
+        locale: Schema.String,
+        minConfidence: Schema.Number,
+      }),
+    },
+    stop: {},
+    diagnose: {
+      output: Schema.Struct({
+        locales: Schema.Array(Schema.String),
+        microphone: Schema.Boolean,
+        selected: Schema.String,
+        error: Schema.String,
+      }),
+    },
+  },
+  events: {
+    final: Schema.Struct({
+      text: Schema.String,
+      confidence: Schema.Number,
+    }),
+    error: Schema.Struct({
+      code: Schema.String,
+      detail: Schema.String,
+      available: Schema.Array(Schema.String),
+    }),
+  },
+})
+
+export interface DiagnoseResult {
+  locales: string[]
+  microphone: boolean
+  selected: string
+  error: string
+}
+
+/**
+ * Text-to-speech bridge. The window speaks with `speechSynthesis` when the
+ * Electron build exposes voices, and falls back to this main-process engine
+ * (`System.Speech.Synthesis`) when it does not.
+ */export const Speech = Ipc.define({
+  id: "voice-dictation.speech",
+  methods: {
+    speak: {
+      input: Schema.Struct({
+        text: Schema.String,
+        rate: Schema.Number,
+        voice: Schema.String,
+      }),
+    },
+    stop: {},
+    voices: {
+      output: Schema.Array(Schema.String),
+    },
+  },
+  events: {
+    done: Schema.Struct({ ok: Schema.Boolean }),
+  },
+})
+
+/**
+ * Windows 11 voice typing. The window focuses the composer and asks main to
+ * press Win+H; Windows writes the text straight into the focused field.
+ */
+export const VoiceTyping = Ipc.define({
+  id: "voice-dictation.voice-typing",
+  methods: {
+    toggle: {},
+  },
+})

package/src/gui/definition.ts

@@ -0,0 +1,204 @@
+import { Schema } from "effect"
+import { Plugin, Store } from "@opencode/plugin/gui"
+
+/**
+ * Declarations read by the desktop app before either setup runs.
+ *
+ * `os: ["windows"]` keeps the plugin from loading on macOS/Linux, where
+ * System.Speech does not exist. Settings shows it as not available instead of
+ * failing.
+ */
+export const definition = Plugin.define({
+  os: ["windows"],
+  stores: {
+    prefs: Store.global(
+      Schema.Struct({
+        locale: Schema.String,
+        minConfidence: Schema.Number,
+        trailingSpace: Schema.Boolean,
+        autoFocus: Schema.Boolean,
+      }),
+      {
+        locale: "es-ES",
+        minConfidence: 0.4,
+        trailingSpace: true,
+        autoFocus: true,
+      },
+    ),
+    speech: Store.global(
+      Schema.Struct({
+        voiceURI: Schema.String,
+        rate: Schema.Number,
+        skipCode: Schema.Boolean,
+      }),
+      {
+        voiceURI: "",
+        rate: 1,
+        skipCode: true,
+      },
+    ),
+    engine: Store.global(
+      Schema.Struct({
+        mode: Schema.String,
+      }),
+      {
+        mode: "windows",
+      },
+    ),
+  },
+  i18n: {
+    en: {
+      "pill.idle": "Dictate",
+      "pill.starting": "Starting…",
+      "pill.listening": "Listening…",
+      "pill.dictating": "Dictating…",
+      "pill.error": "Retry dictation",
+      "pill.title": "Voice dictation",
+      "pill.winH": "Open Windows voice typing (Win+H)",
+      "pill.stop": "Stop dictation",
+      "command.toggle": "Toggle voice dictation",
+      "command.toggle.description": "Dictate into the prompt with the selected engine",
+      "command.configure": "Voice dictation settings",
+      "error.title": "Voice dictation",
+      "error.language": "The speech language {locale} is not installed. Available: {available}.",
+      "error.none": "Windows has no speech recognizer installed. Settings › Time & language › Language › Speech.",
+      "error.mic": "No microphone is available for speech recognition.",
+      "error.system": "System.Speech is not available in this Windows installation.",
+      "error.exit": "The dictation engine stopped unexpectedly.",
+      "error.unknown": "Dictation failed ({code}).",
+      "toast.discarded": "Dictation discarded: the active session changed.",
+      "settings.title": "Voice dictation",
+      "settings.description": "Offline dictation with the Windows speech recognizer. The text is inserted into the prompt; it is never sent automatically.",
+      "settings.section": "Dictation",
+      "settings.engine": "Dictation engine",
+      "settings.engine.description": "Windows uses Windows 11 voice typing (Win+H), which is more accurate. System.Speech works offline but is less precise.",
+      "engine.windows": "Windows Voice Typing (Win+H)",
+      "engine.system": "System.Speech (offline)",
+      "settings.winh": "Test Win+H",
+      "settings.winh.description": "Sends the Windows voice typing shortcut. If the floating bar appears, it works.",
+      "settings.winh.run": "Test Win+H",
+      "settings.winh.sent": "Win+H sent. If the Windows dictation bar did not appear, check Settings › Accessibility › Voice typing.",
+      "error.winh": "Windows voice typing could not be triggered.",
+      "settings.language": "Language",
+      "settings.language.description": "A speech recognizer installed in Windows. Accents and punctuation depend on it.",
+      "settings.confidence": "Minimum confidence",
+      "settings.confidence.description": "Results below this threshold are ignored to avoid noise.",
+      "confidence.low": "Low (0.2)",
+      "confidence.normal": "Normal (0.4)",
+      "confidence.high": "High (0.6)",
+      "settings.space": "Add a space before the text",
+      "settings.space.description": "Separates the dictation from what is already in the prompt.",
+      "settings.focus": "Focus the prompt after dictating",
+      "settings.focus.description": "Moves the cursor to the prompt so you can review or send it.",
+      "settings.test.section": "Diagnostics",
+      "settings.test": "Test microphone",
+      "settings.test.description": "Checks installed recognizers and the default microphone.",
+      "settings.test.run": "Run test",
+      "settings.test.success": "Speech recognition ready: {locale}",
+      "settings.test.failed": "Not ready: {reason}",
+      "common.reason.no-recognizers": "no speech language installed",
+      "common.reason.no-microphone": "no microphone available",
+      "read.idle": "Read",
+      "read.speaking": "Reading…",
+      "read.stop": "Stop reading",
+      "read.title": "Read the last message aloud",
+      "command.read": "Read the last message aloud",
+      "command.read.description": "Speaks the last reply with a system voice",
+      "read.noSession": "Open a conversation to read its last message.",
+      "read.empty": "The last message has no text to read.",
+      "read.error": "The last message could not be read.",
+      "read.noVoices": "Windows has no voices installed for reading.",
+      "speech.section": "Read aloud",
+      "speech.voice": "Voice",
+      "speech.voice.description": "A system voice. Automatic picks one in the app language.",
+      "speech.voice.auto": "Automatic",
+      "speech.rate": "Speed",
+      "speech.rate.description": "How fast the text is spoken.",
+      "speech.rate.slow": "0.8×",
+      "speech.rate.normal": "1×",
+      "speech.rate.fast": "1.2×",
+      "speech.rate.faster": "1.5×",
+      "speech.skipCode": "Skip code blocks",
+      "speech.skipCode.description": "Read only the prose; code, paths and commands are left out.",
+      "speech.preview": "Test voice",
+      "speech.preview.description": "Speaks a short sample with the current voice and speed.",
+      "speech.preview.text": "Hello, this is a reading test.",
+    },
+    es: {
+      "pill.idle": "Dictar",
+      "pill.starting": "Iniciando…",
+      "pill.listening": "Escuchando…",
+      "pill.dictating": "Dictando…",
+      "pill.error": "Reintentar dictado",
+      "pill.title": "Dictado por voz",
+      "pill.winH": "Abrir el dictado de Windows (Win+H)",
+      "pill.stop": "Detener dictado",
+      "command.toggle": "Alternar dictado por voz",
+      "command.toggle.description": "Dicta en el prompt con el motor elegido",
+      "command.configure": "Ajustes de dictado por voz",
+      "error.title": "Dictado por voz",
+      "error.language": "El idioma de reconocimiento {locale} no está instalado. Disponibles: {available}.",
+      "error.none": "Windows no tiene ningún reconocedor de voz instalado. Configuración › Hora e idioma › Idioma › Voz.",
+      "error.mic": "No hay ningún micrófono disponible para el reconocimiento de voz.",
+      "error.system": "System.Speech no está disponible en esta instalación de Windows.",
+      "error.exit": "El motor de dictado se detuvo inesperadamente.",
+      "error.unknown": "El dictado falló ({code}).",
+      "toast.discarded": "Dictado descartado: la sesión activa cambió.",
+      "settings.title": "Dictado por voz",
+      "settings.description": "Dictado offline con el reconocedor de voz de Windows. El texto se inserta en el prompt; nunca se envía solo.",
+      "settings.section": "Dictado",
+      "settings.engine": "Motor de dictado",
+      "settings.engine.description": "Windows usa el dictado de Windows 11 (Win+H), más preciso. System.Speech funciona sin Windows 11 pero es menos exacto.",
+      "engine.windows": "Windows Voice Typing (Win+H)",
+      "engine.system": "System.Speech (offline)",
+      "settings.winh": "Probar Win+H",
+      "settings.winh.description": "Envía el atajo del dictado de Windows. Si aparece la barra flotante, funciona.",
+      "settings.winh.run": "Probar Win+H",
+      "settings.winh.sent": "Win+H enviado. Si no apareció la barra, revisa Configuración › Accesibilidad › Dictado por voz.",
+      "settings.language": "Idioma",
+      "settings.language.description": "Un reconocedor instalado en Windows. Los acentos y la puntuación dependen de él.",
+      "settings.confidence": "Confianza mínima",
+      "settings.confidence.description": "Los resultados por debajo de este umbral se ignoran para evitar ruido.",
+      "confidence.low": "Baja (0,2)",
+      "confidence.normal": "Normal (0,4)",
+      "confidence.high": "Alta (0,6)",
+      "settings.space": "Añadir un espacio antes del texto",
+      "settings.space.description": "Separa el dictado de lo que ya hay en el prompt.",
+      "settings.focus": "Enfocar el prompt al terminar",
+      "settings.focus.description": "Mueve el cursor al prompt para revisar o enviar el texto.",
+      "settings.test.section": "Diagnóstico",
+      "settings.test": "Probar micrófono",
+      "settings.test.description": "Comprueba los reconocedores instalados y el micrófono predeterminado.",
+      "settings.test.run": "Ejecutar prueba",
+      "settings.test.success": "Reconocimiento de voz listo: {locale}",
+      "settings.test.failed": "No está listo: {reason}",
+      "common.reason.no-recognizers": "no hay ningún idioma de voz instalado",
+      "common.reason.no-microphone": "no hay micrófono disponible",
+      "read.idle": "Leer",
+      "read.speaking": "Leyendo…",
+      "read.stop": "Detener lectura",
+      "read.title": "Leer en voz alta el último mensaje",
+      "command.read": "Leer en voz alta el último mensaje",
+      "command.read.description": "Reproduce la última respuesta con una voz del sistema",
+      "read.noSession": "Abre una conversación para leer su último mensaje.",
+      "read.empty": "El último mensaje no tiene texto para leer.",
+      "read.error": "No se pudo leer el último mensaje.",
+      "read.noVoices": "Windows no tiene voces instaladas para la lectura.",
+      "speech.section": "Lectura en voz alta",
+      "speech.voice": "Voz",
+      "speech.voice.description": "Una voz del sistema. Automática elige una en el idioma de la app.",
+      "speech.voice.auto": "Automática",
+      "speech.rate": "Velocidad",
+      "speech.rate.description": "A qué ritmo se lee el texto.",
+      "speech.rate.slow": "0,8×",
+      "speech.rate.normal": "1×",
+      "speech.rate.fast": "1,2×",
+      "speech.rate.faster": "1,5×",
+      "speech.skipCode": "Ignorar bloques de código",
+      "speech.skipCode.description": "Lee solo la prosa; omite código, rutas y comandos.",
+      "speech.preview": "Probar voz",
+      "speech.preview.description": "Lee una frase corta con la voz y velocidad actuales.",
+      "speech.preview.text": "Hola, esta es una prueba de lectura.",
+    },
+  },
+})

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

@@ -0,0 +1,151 @@
+import { spawn, type ChildProcess } from "node:child_process"
+import { createHash, randomUUID } from "node:crypto"
+import { mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { SPEAK_SCRIPT } from "./speak-script"
+
+const POWERSHELL = "powershell.exe"
+
+export interface SpeakInput {
+  text: string
+  rate: number
+  voice: string
+}
+
+export interface SpeakHandle {
+  stop(): void
+}
+
+function workDir(): string {
+  const dir = join(tmpdir(), "opencode-voice-dictation")
+  mkdirSync(dir, { recursive: true })
+  return dir
+}
+
+function scriptFile(): string {
+  const hash = createHash("sha1").update(SPEAK_SCRIPT).digest("hex").slice(0, 12)
+  const file = join(workDir(), `speak-${hash}.ps1`)
+  writeFileSync(file, SPEAK_SCRIPT, "utf8")
+  return file
+}
+
+function textFile(text: string): string {
+  const file = join(workDir(), `speech-${randomUUID()}.txt`)
+  writeFileSync(file, text, "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())
+}
+
+/** Maps the Web Speech `rate` scale (0.1–10, 1 = normal) to SAPI's -10…10. */
+function sapiRate(rate: number): number {
+  return Math.max(-10, Math.min(10, Math.round((rate - 1) * 5)))
+}
+
+export function speakSapi(input: SpeakInput, onDone: (ok: boolean) => void): SpeakHandle {
+  const file = textFile(input.text)
+
+  const child = spawnPowershell([
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-File",
+    scriptFile(),
+    "-TextFile",
+    file,
+    "-Rate",
+    String(sapiRate(input.rate)),
+    "-Voice",
+    input.voice,
+  ])
+
+  let stopped = false
+
+  const clean = () => {
+    try {
+      rmSync(file, { force: true })
+    } catch {
+      // Best effort: the temp folder is cleaned by the OS anyway.
+    }
+  }
+
+  child.on("error", () => {
+    clean()
+    if (!stopped) onDone(false)
+  })
+
+  child.on("close", (code) => {
+    clean()
+    if (!stopped) onDone(code === 0)
+  })
+
+  return {
+    stop() {
+      stopped = true
+      killTree(child)
+      clean()
+    },
+  }
+}
+
+export function listSapiVoices(): Promise<string[]> {
+  return new Promise((resolve) => {
+    const child = spawnPowershell([
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      scriptFile(),
+      "-ListVoices",
+    ])
+
+    let stdout = ""
+    let settled = false
+
+    const finish = (names: string[]) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve(names)
+    }
+
+    const timer = setTimeout(() => {
+      killTree(child)
+      finish([])
+    }, 10000)
+
+    child.stdout?.setEncoding("utf8")
+    child.stdout?.on("data", (chunk: string) => {
+      stdout += chunk
+    })
+    child.on("error", () => finish([]))
+    child.on("close", () => {
+      const names = stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+      finish(names)
+    })
+  })
+}

package/src/gui/engines/script.ts

@@ -0,0 +1,125 @@
+/**
+ * The Windows speech engine, written to a temporary `.ps1` file at runtime.
+ *
+ * It is embedded instead of shipped as a resource so the single-file GUI
+ * bundle never has to resolve a path to it.
+ *
+ * Protocol: one JSON object per line on stdout, flushed after every event.
+ *
+ *   {"type":"ready","locale":"es-ES","requested":"es-ES"}
+ *   {"type":"final","text":"hola","confidence":0.82,"locale":"es-ES"}
+ *   {"type":"error","code":"...","detail":"...","available":["en-US"]}
+ *   {"type":"diagnose","locales":[...],"microphone":true,"selected":"es-ES","error":""}
+ *
+ * Keep the file ASCII-only: Windows PowerShell 5.1 reads a BOM-less script as
+ * ANSI. Write `$` and avoid `${...}` and backticks so it survives the template
+ * literal.
+ */
+export const DICTATION_SCRIPT = String.raw`param(
+  [string]$Culture = "es-ES",
+  [double]$MinConfidence = 0.4,
+  [switch]$Diagnose
+)
+
+$ErrorActionPreference = "Stop"
+
+try {
+  $utf8 = New-Object System.Text.UTF8Encoding($false)
+  [Console]::OutputEncoding = $utf8
+} catch { }
+
+function Emit {
+  param([hashtable]$Payload)
+  [Console]::Out.WriteLine(($Payload | ConvertTo-Json -Compress))
+  [Console]::Out.Flush()
+}
+
+try {
+  Add-Type -AssemblyName System.Speech
+} catch {
+  Emit @{ type = "error"; code = "SYSTEM_SPEECH_UNAVAILABLE"; detail = "$($_.Exception.Message)"; available = @() }
+  exit 2
+}
+
+$installed = @()
+try {
+  foreach ($entry in [System.Speech.Recognition.SpeechRecognitionEngine]::InstalledRecognizers()) {
+    $installed += $entry.Culture.Name
+  }
+} catch { }
+
+$selected = ""
+foreach ($name in $installed) {
+  if ($name -eq $Culture) { $selected = $name; break }
+}
+if ($selected -eq "") {
+  $base = ($Culture -split "-")[0]
+  foreach ($name in $installed) {
+    if (($name -split "-")[0] -eq $base) { $selected = $name; break }
+  }
+}
+
+if ($Diagnose) {
+  $microphone = $false
+  $problem = ""
+  if ($installed.Count -gt 0) {
+    try {
+      $probeCulture = New-Object System.Globalization.CultureInfo($installed[0])
+      $probe = New-Object System.Speech.Recognition.SpeechRecognitionEngine($probeCulture)
+      $probe.SetInputToDefaultAudioDevice()
+      $microphone = $true
+      $probe.Dispose()
+    } catch {
+      $problem = "$($_.Exception.Message)"
+    }
+  } else {
+    $problem = "NO_RECOGNIZERS"
+  }
+  Emit @{ type = "diagnose"; locales = @($installed); microphone = $microphone; selected = $selected; error = $problem }
+  exit 0
+}
+
+if ($installed.Count -eq 0) {
+  Emit @{ type = "error"; code = "NO_RECOGNIZERS"; detail = ""; available = @() }
+  exit 3
+}
+
+if ($selected -eq "") {
+  Emit @{ type = "error"; code = "LANGUAGE_NOT_AVAILABLE"; detail = $Culture; available = @($installed) }
+  exit 4
+}
+
+try {
+  $cultureInfo = New-Object System.Globalization.CultureInfo($selected)
+  $recognizer = New-Object System.Speech.Recognition.SpeechRecognitionEngine($cultureInfo)
+  $recognizer.LoadGrammar((New-Object System.Speech.Recognition.DictationGrammar))
+  $recognizer.InitialSilenceTimeout = [TimeSpan]::FromSeconds(10)
+  $recognizer.BabbleTimeout = [TimeSpan]::FromSeconds(5)
+  $recognizer.EndSilenceTimeout = [TimeSpan]::FromSeconds(0.6)
+  $recognizer.EndSilenceTimeoutAmbiguous = [TimeSpan]::FromSeconds(1.2)
+  $recognizer.SetInputToDefaultAudioDevice()
+} catch {
+  Emit @{ type = "error"; code = "MICROPHONE_UNAVAILABLE"; detail = "$($_.Exception.Message)"; available = @($installed) }
+  exit 5
+}
+
+Emit @{ type = "ready"; locale = $selected; requested = $Culture }
+
+$failures = 0
+while ($true) {
+  try {
+    $result = $recognizer.Recognize([TimeSpan]::FromSeconds(5))
+    $failures = 0
+    if ($result -ne $null -and $result.Text -ne "" -and $result.Confidence -ge $MinConfidence) {
+      Emit @{ type = "final"; text = $result.Text; confidence = [math]::Round($result.Confidence, 3); locale = $selected }
+    }
+  } catch {
+    $failures++
+    if ($failures -ge 5) {
+      Emit @{ type = "error"; code = "RECOGNITION_FAILED"; detail = "$($_.Exception.Message)"; available = @() }
+      exit 6
+    }
+    Start-Sleep -Milliseconds 250
+  }
+}
+`

package/src/gui/engines/speak-script.ts

@@ -0,0 +1,66 @@
+/**
+ * Text-to-speech fallback with `System.Speech.Synthesis`, written to a
+ * temporary `.ps1` file at runtime.
+ *
+ * It reads the text from a UTF-8 file instead of the command line, so long
+ * messages and any character (accents, quotes, newlines) travel intact.
+ *
+ * `-ListVoices` prints one installed voice name per line.
+ *
+ * Keep the file ASCII-only: Windows PowerShell 5.1 reads a BOM-less script as
+ * ANSI.
+ */
+export const SPEAK_SCRIPT = String.raw`param(
+  [string]$TextFile = "",
+  [int]$Rate = 0,
+  [string]$Voice = "",
+  [switch]$ListVoices
+)
+
+$ErrorActionPreference = "Stop"
+
+try {
+  $utf8 = New-Object System.Text.UTF8Encoding($false)
+  [Console]::OutputEncoding = $utf8
+} catch { }
+
+try {
+  Add-Type -AssemblyName System.Speech
+} catch {
+  exit 2
+}
+
+try {
+  $synth = New-Object System.Speech.Synthesis.SpeechSynthesizer
+} catch {
+  exit 3
+}
+
+if ($ListVoices) {
+  try {
+    foreach ($entry in $synth.GetInstalledVoices()) {
+      if ($entry.Enabled) {
+        [Console]::Out.WriteLine($entry.VoiceInfo.Name)
+      }
+    }
+  } catch { }
+  $synth.Dispose()
+  exit 0
+}
+
+if ($Rate -lt -10) { $Rate = -10 }
+if ($Rate -gt 10) { $Rate = 10 }
+
+try { $synth.Rate = $Rate } catch { }
+
+if ($Voice -ne "") {
+  try { $synth.SelectVoice($Voice) } catch { }
+}
+
+try {
+  $text = [System.IO.File]::ReadAllText($TextFile, [System.Text.Encoding]::UTF8)
+  $synth.Speak($text)
+} catch { }
+
+$synth.Dispose()
+`