opencode-voice-dictation 0.8.1 → 0.9.0

package/README.md

@@ -1,12 +1,13 @@
-# Dictado por voz para OpenCode Desktop
+# Dictado por voz para OpenCode Desktop y TUI
 
 Plugin de [OpenCode](https://opencode.ai) V2 que añade voz a la app de
-escritorio:
+escritorio y a la TUI:
 
 - **Dictado**: pulsas la píldora y se abre el dictado de Windows 11 (Win+H),
   que escribe en el prompt con su motor neuronal. También puedes usar el motor
   offline `System.Speech` desde Ajustes.
 - **Lectura**: pulsa «Leer» y reproduce en voz alta la última respuesta.
+- **TUI**: usa `/dictado` y `/leer` (o `<leader>d` y `<leader>v`) en la terminal.
 
 - **Dictado preciso**: por defecto delega en Windows Voice Typing (Win+H).
 - **Modo offline**: `System.Speech` sigue disponible como alternativa sin
@@ -28,8 +29,8 @@ escritorio:
 opencode plugin add opencode-voice-dictation
 ```
 
-Reinicia OpenCode Desktop. El plugin queda registrado en el `opencode.json`
-global del entorno donde ejecutes el comando.
+Reinicia OpenCode Desktop o la TUI. El plugin queda registrado en el
+`opencode.json` global del entorno donde ejecutes el comando.
 
 Actualizar:
 
@@ -44,6 +45,20 @@ está commiteado):
 opencode plugin add github:evious/opencode-voice-dictation
 ```
 
+## TUI (terminal)
+
+El paquete también exporta una parte TUI. En Windows puedes dictar y escuchar
+la última respuesta sin salir de la terminal:
+
+| Comando | Atajo | Acción |
+| --- | --- | --- |
+| `/dictado` | `<leader>d` (`Ctrl+X`, luego `d`) | Abre el dictado de Windows (Win+H) en el prompt. |
+| `/leer` | `<leader>v` (`Ctrl+X`, luego `v`) | Lee la última respuesta. Si ya está leyendo, la detiene. |
+
+La lectura usa las voces neuronales de Edge y, si falla la red o la
+reproducción, cae en la voz del sistema. El dictado de la TUI requiere Windows
+por ahora; Linux se añadirá más adelante.
+
 ## Compatibilidad
 
 Probado con OpenCode Desktop **2.2.6** en Windows 11 y Ubuntu 24.04. La API de

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-voice-dictation",
-  "version": "0.8.1",
-  "description": "Offline voice dictation and read-aloud for OpenCode Desktop on Windows and Linux",
+  "version": "0.9.0",
+  "description": "Offline voice dictation and read-aloud for OpenCode Desktop and TUI on Windows and Linux",
   "license": "MIT",
   "author": "Fran Carlos <francarlos803@gmail.com>",
   "homepage": "https://github.com/evious/opencode-voice-dictation#readme",
@@ -15,6 +15,8 @@
   "keywords": [
     "opencode",
     "opencode-plugin",
+    "tui",
+    "terminal",
     "voice",
     "dictation",
     "speech-to-text",
@@ -28,7 +30,8 @@
   "exports": {
     ".": "./src/index.ts",
     "./gui-experimental": "./dist/gui-experimental.cjs",
-    "./rpc": "./src/rpc.ts"
+    "./rpc": "./src/rpc.ts",
+    "./tui": "./src/tui.ts"
   },
   "files": [
     "src",
@@ -38,8 +41,8 @@
     "docs"
   ],
   "dependencies": {
-    "msedge-tts": "^2.1.1",
-    "@opencode/plugin": "2.2.6"
+    "@opencode/plugin": "2.2.6",
+    "msedge-tts": "^2.1.1"
   },
   "publishConfig": {
     "access": "public"
@@ -47,11 +50,14 @@
   "scripts": {
     "build": "vite build",
     "dev": "vite build --watch",
-    "test": "node test/smoke.cjs",
+    "test": "node test/speech-text.cjs && node test/tui.cjs && node test/smoke.cjs",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run typecheck && npm run build && npm test"
   },
   "devDependencies": {
+    "@opencode/theme": "^2.2.6",
+    "@opentui/core": "^0.8.1",
+    "@opentui/solid": "^0.8.1",
     "@types/node": "^24.0.0",
     "effect": "4.1.0",
     "solid-js": "^1.9.17",

package/src/gui/main.ts

@@ -1,8 +1,8 @@
 import type { Plugin } from "@opencode/plugin/gui"
 import { Dictation, Speech, VoiceTyping } from "./contract"
 import { diagnose, startEngine, type EngineHandle } from "./engines/system-speech"
-import { listSapiVoices, speakSapi, type SpeakHandle } from "./engines/sapi-speech"
-import { sendVoiceTypingShortcut } from "./engines/win-h"
+import { listSapiVoices, speakSapi, type SpeakHandle } from "../sapi-speech"
+import { sendVoiceTypingShortcut } from "../win-h"
 
 type Status = "idle" | "starting" | "listening" | "error"
 

package/src/gui/speak.ts

@@ -1,6 +1,7 @@
 import { createSignal } from "solid-js"
 import type { IpcClient, SetupContext } from "@opencode/plugin/gui"
 import { VoiceRpc } from "../rpc"
+import { cleanForSpeech, chunkForSpeech } from "../speech-text"
 import { Speech } from "./contract"
 import type { definition } from "./definition"
 
@@ -30,81 +31,7 @@ export interface Speaker {
   preview(): Promise<boolean>
 }
 
-const MAX_CHUNK = 250
-
-/** Turns Markdown into something worth hearing. */
-export function cleanForSpeech(text: string, skipCode: boolean): string {
-  let value = text.replace(/\r\n/g, "\n")
-
-  if (skipCode) {
-    value = value.replace(/```[\s\S]*?```/g, " ")
-  } else {
-    value = value.replace(/```[^\n]*\n([\s\S]*?)```/g, "$1")
-  }
-
-  value = value.replace(/`([^`]+)`/g, "$1")
-  value = value.replace(/!\[[^\]]*\]\([^)]*\)/g, " ")
-  value = value.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
-  value = value.replace(/^\s*#{1,6}\s+/gm, "")
-  value = value.replace(/^\s*>\s?/gm, "")
-  value = value.replace(/^\s*[-*+]\s+/gm, "")
-  value = value.replace(/^\s*\d+\.\s+/gm, "")
-  value = value.replace(/(\*\*|__)(.*?)\1/g, "$2")
-  value = value.replace(/(\*|_)(.*?)\1/g, "$2")
-  value = value.replace(/^\s*\|.*\|\s*$/gm, " ")
-  value = value.replace(/\n{2,}/g, ". ")
-  value = value.replace(/\n/g, " ")
-  value = value.replace(/\s+/g, " ")
-  value = value.replace(/\s+([.,;:!?])/g, "$1")
-  value = value.replace(/([.,;:!?]){2,}/g, "$1")
-
-  return value.trim()
-}
-
-/** Splits at sentence boundaries, then at word boundaries for long sentences. */
-export function chunkForSpeech(text: string, max = MAX_CHUNK): string[] {
-  const trimmed = text.trim()
-  if (!trimmed) return []
-
-  const sentences = trimmed.split(/(?<=[.!?…])\s+/)
-  const chunks: string[] = []
-  let current = ""
-
-  const pushWords = (sentence: string) => {
-    let part = ""
-    for (const word of sentence.split(/\s+/)) {
-      if (!word) continue
-      if (part && part.length + 1 + word.length > max) {
-        chunks.push(part)
-        part = word
-      } else {
-        part = part ? `${part} ${word}` : word
-      }
-    }
-    return part
-  }
-
-  for (const sentence of sentences) {
-    if (sentence.length > max) {
-      if (current) {
-        chunks.push(current)
-        current = ""
-      }
-      current = pushWords(sentence)
-      continue
-    }
-
-    if (current && current.length + 1 + sentence.length > max) {
-      chunks.push(current)
-      current = sentence
-    } else {
-      current = current ? `${current} ${sentence}` : sentence
-    }
-  }
-
-  if (current) chunks.push(current)
-  return chunks
-}
+export { cleanForSpeech, chunkForSpeech } from "../speech-text"
 
 export function createSpeaker(
   ctx: SetupContext<typeof definition>,

package/src/{gui/engines/sapi-speech.ts → sapi-speech.ts}

@@ -3,7 +3,7 @@ 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"
+import { SPEAK_SCRIPT } from "./speak-script.js"
 
 const POWERSHELL = "powershell.exe"
 

package/src/speech-text.ts

@@ -0,0 +1,75 @@
+const MAX_CHUNK = 250
+
+/** Turns Markdown into something worth hearing. */
+export function cleanForSpeech(text: string, skipCode: boolean): string {
+  let value = text.replace(/\r\n/g, "\n")
+
+  if (skipCode) {
+    value = value.replace(/```[\s\S]*?```/g, " ")
+  } else {
+    value = value.replace(/```[^\n]*\n([\s\S]*?)```/g, "$1")
+  }
+
+  value = value.replace(/`([^`]+)`/g, "$1")
+  value = value.replace(/!\[[^\]]*\]\([^)]*\)/g, " ")
+  value = value.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+  value = value.replace(/^\s*#{1,6}\s+/gm, "")
+  value = value.replace(/^\s*>\s?/gm, "")
+  value = value.replace(/^\s*[-*+]\s+/gm, "")
+  value = value.replace(/^\s*\d+\.\s+/gm, "")
+  value = value.replace(/(\*\*|__)(.*?)\1/g, "$2")
+  value = value.replace(/(\*|_)(.*?)\1/g, "$2")
+  value = value.replace(/^\s*\|.*\|\s*$/gm, " ")
+  value = value.replace(/\n{2,}/g, ". ")
+  value = value.replace(/\n/g, " ")
+  value = value.replace(/\s+/g, " ")
+  value = value.replace(/\s+([.,;:!?])/g, "$1")
+  value = value.replace(/([.,;:!?]){2,}/g, "$1")
+
+  return value.trim()
+}
+
+/** Splits at sentence boundaries, then at word boundaries for long sentences. */
+export function chunkForSpeech(text: string, max = MAX_CHUNK): string[] {
+  const trimmed = text.trim()
+  if (!trimmed) return []
+
+  const sentences = trimmed.split(/(?<=[.!?…])\s+/)
+  const chunks: string[] = []
+  let current = ""
+
+  const pushWords = (sentence: string) => {
+    let part = ""
+    for (const word of sentence.split(/\s+/)) {
+      if (!word) continue
+      if (part && part.length + 1 + word.length > max) {
+        chunks.push(part)
+        part = word
+      } else {
+        part = part ? `${part} ${word}` : word
+      }
+    }
+    return part
+  }
+
+  for (const sentence of sentences) {
+    if (sentence.length > max) {
+      if (current) {
+        chunks.push(current)
+        current = ""
+      }
+      current = pushWords(sentence)
+      continue
+    }
+
+    if (current && current.length + 1 + sentence.length > max) {
+      chunks.push(current)
+      current = sentence
+    } else {
+      current = current ? `${current} ${sentence}` : sentence
+    }
+  }
+
+  if (current) chunks.push(current)
+  return chunks
+}

package/src/tui/player.ts

@@ -0,0 +1,128 @@
+import { spawn, type ChildProcess } from "node:child_process"
+import { randomUUID } from "node:crypto"
+import { mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+const POWERSHELL = "powershell.exe"
+
+const PLAYER_SCRIPT = `param(
+  [Parameter(Mandatory = $true)][string]$Path
+)
+
+$ErrorActionPreference = "Stop"
+$player = $null
+
+try {
+  [Windows.Media.Playback.MediaPlayer, Windows.Media.Playback, ContentType = WindowsRuntime] | Out-Null
+  [Windows.Media.Core.MediaSource, Windows.Media.Core, ContentType = WindowsRuntime] | Out-Null
+
+  $player = [Windows.Media.Playback.MediaPlayer]::new()
+  $player.Source = [Windows.Media.Core.MediaSource]::CreateFromUri([Uri]$Path)
+  $player.Play()
+
+  $deadline = [DateTime]::UtcNow.AddSeconds(5)
+  $duration = 0
+  do {
+    Start-Sleep -Milliseconds 50
+    $duration = $player.PlaybackSession.NaturalDuration.TotalMilliseconds
+  } while ($duration -le 0 -and [DateTime]::UtcNow -lt $deadline)
+
+  if ($duration -le 0) {
+    $player.Dispose()
+    exit 5
+  }
+
+  Start-Sleep -Milliseconds ([int]$duration + 350)
+  $player.Pause()
+  $player.Dispose()
+  exit 0
+} catch {
+  if ($null -ne $player) {
+    try { $player.Dispose() } catch { }
+  }
+  Write-Error $_
+  exit 4
+}
+`
+
+export interface Playback {
+  stop(): void
+  done: Promise<boolean>
+}
+
+function workDir(): string {
+  const dir = join(tmpdir(), "opencode-voice-dictation")
+  mkdirSync(dir, { recursive: true })
+  return dir
+}
+
+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 playMp3Base64(base64: string): Playback {
+  if (process.platform !== "win32") {
+    return { stop() {}, done: Promise.resolve(false) }
+  }
+
+  const id = randomUUID()
+  const file = join(workDir(), `speech-${id}.mp3`)
+  const script = join(workDir(), `speech-${id}.ps1`)
+  writeFileSync(file, Buffer.from(base64, "base64"))
+  writeFileSync(script, PLAYER_SCRIPT, "utf8")
+
+  let child: ChildProcess | undefined
+  let settled = false
+  let resolveDone!: (ok: boolean) => void
+  const done = new Promise<boolean>((resolve) => {
+    resolveDone = resolve
+  })
+
+  const clean = () => {
+    for (const path of [file, script]) {
+      try {
+        rmSync(path, { force: true })
+      } catch {
+        // Best effort: the temp folder is cleaned by the OS anyway.
+      }
+    }
+  }
+
+  const finish = (ok: boolean) => {
+    if (settled) return
+    settled = true
+    clean()
+    resolveDone(ok)
+  }
+
+  child = spawn(
+    POWERSHELL,
+    ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", script, "-Path", file],
+    {
+      windowsHide: true,
+      stdio: "ignore",
+    },
+  )
+
+  child.on("error", () => finish(false))
+  child.on("close", (code) => finish(code === 0))
+
+  return {
+    stop() {
+      if (settled) return
+      if (child) killTree(child)
+      finish(false)
+    },
+    done,
+  }
+}

package/src/tui.ts

@@ -0,0 +1,253 @@
+import { Plugin } from "@opencode/plugin/tui"
+import { VoiceRpc } from "./rpc.js"
+import { chunkForSpeech, cleanForSpeech } from "./speech-text.js"
+import { speakSapi, type SpeakHandle } from "./sapi-speech.js"
+import { playMp3Base64, type Playback } from "./tui/player.js"
+import { sendVoiceTypingShortcut } from "./win-h.js"
+
+const DEFAULT_VOICE = "es-ES-XimenaNeural"
+const DEFAULT_RATE = 1
+const MAX_EDGE_CHUNK = 4000
+
+function errorMessage(error: unknown): string {
+  if (error instanceof Error && error.message) return error.message
+  if (typeof error === "string" && error) return error
+  return "error desconocido"
+}
+
+export default Plugin.define({
+  id: "voice-dictation.tui",
+  setup(context) {
+    const voice = typeof context.options.voice === "string" ? context.options.voice : DEFAULT_VOICE
+    const rate = typeof context.options.rate === "number" ? context.options.rate : DEFAULT_RATE
+    const skipCode = typeof context.options.skipCode === "boolean" ? context.options.skipCode : true
+
+    let generation = 0
+    let busy = false
+    let active: { stop(): void } | undefined
+
+    const stop = () => {
+      generation++
+      active?.stop()
+      active = undefined
+      busy = false
+    }
+
+    const dictate = async () => {
+      if (process.platform !== "win32") {
+        context.ui.toast.show({
+          title: "Dictado por voz",
+          message: "El dictado de la TUI está disponible solo en Windows por ahora.",
+          variant: "warning",
+        })
+        return
+      }
+
+      try {
+        await sendVoiceTypingShortcut()
+        context.ui.toast.show({
+          title: "Dictado por voz",
+          message: "Dictado de Windows abierto. Habla y el texto aparecerá en el prompt.",
+          variant: "info",
+        })
+      } catch (error) {
+        context.ui.toast.show({
+          title: "Dictado por voz",
+          message: `No se pudo abrir el dictado: ${errorMessage(error)}`,
+          variant: "error",
+        })
+      }
+    }
+
+    const speakSystem = (text: string, current: number) => {
+      return new Promise<void>((resolve) => {
+        let settled = false
+        let wrapper: { stop(): void } | undefined
+
+        const finish = () => {
+          if (settled) return
+          settled = true
+          if (active === wrapper) active = undefined
+          resolve()
+        }
+
+        const handle: SpeakHandle = speakSapi({ text, rate, voice: "" }, (ok) => {
+          if (!ok && current === generation) {
+            context.ui.toast.show({
+              title: "Dictado por voz",
+              message: "Tampoco se pudo reproducir con la voz del sistema.",
+              variant: "error",
+            })
+          }
+          finish()
+        })
+
+        wrapper = {
+          stop() {
+            handle.stop()
+            finish()
+          },
+        }
+        active = wrapper
+
+        if (current !== generation) {
+          handle.stop()
+          finish()
+        }
+      })
+    }
+
+    const read = async () => {
+      if (busy || active) {
+        stop()
+        context.ui.toast.show({
+          title: "Dictado por voz",
+          message: "Lectura detenida.",
+          variant: "info",
+        })
+        return
+      }
+
+      if (process.platform !== "win32") {
+        context.ui.toast.show({
+          title: "Dictado por voz",
+          message: "La lectura de la TUI está disponible solo en Windows por ahora.",
+          variant: "warning",
+        })
+        return
+      }
+
+      const route = context.ui.router.current()
+      if (route.type !== "session") {
+        context.ui.toast.show({
+          title: "Dictado por voz",
+          message: "Abre una sesión para leer su última respuesta.",
+          variant: "warning",
+        })
+        return
+      }
+
+      const current = ++generation
+      busy = true
+
+      try {
+        const response = await context.client.message.list({
+          sessionID: route.sessionID,
+          type: "assistant",
+          order: "desc",
+          limit: 10,
+        })
+        if (current !== generation) return
+
+        const message = response.data.find(
+          (entry) =>
+            entry.type === "assistant" &&
+            entry.content.some((part) => part.type === "text" && part.text.trim().length > 0),
+        )
+        if (!message || message.type !== "assistant") {
+          context.ui.toast.show({
+            title: "Dictado por voz",
+            message: "No hay una respuesta para leer.",
+            variant: "info",
+          })
+          return
+        }
+
+        const text = message.content
+          .filter((part) => part.type === "text")
+          .map((part) => part.text)
+          .join("\n")
+        const cleaned = cleanForSpeech(text, skipCode)
+        if (!cleaned) {
+          context.ui.toast.show({
+            title: "Dictado por voz",
+            message: "La última respuesta no tiene texto para leer.",
+            variant: "info",
+          })
+          return
+        }
+
+        let edgeFailed = false
+        for (const chunk of chunkForSpeech(cleaned, MAX_EDGE_CHUNK)) {
+          if (current !== generation) return
+
+          let audio: string
+          try {
+            const result = await context.client.rpc(VoiceRpc).edgeSpeak({ text: chunk, voice, rate })
+            if (typeof result !== "string" || result.length === 0) {
+              edgeFailed = true
+              break
+            }
+            audio = result
+          } catch {
+            edgeFailed = true
+            break
+          }
+          if (current !== generation) return
+
+          const playback: Playback = playMp3Base64(audio)
+          active = playback
+          const ok = await playback.done
+          if (active === playback) active = undefined
+          if (current !== generation) return
+
+          if (!ok) {
+            edgeFailed = true
+            break
+          }
+        }
+
+        if (!edgeFailed || current !== generation) return
+
+        context.ui.toast.show({
+          title: "Dictado por voz",
+          message: "No se pudo usar Edge. Usando la voz del sistema.",
+          variant: "warning",
+        })
+        await speakSystem(cleaned, current)
+      } catch (error) {
+        if (current === generation) {
+          context.ui.toast.show({
+            title: "Dictado por voz",
+            message: `No se pudo leer la respuesta: ${errorMessage(error)}`,
+            variant: "error",
+          })
+        }
+      } finally {
+        if (current === generation) busy = false
+      }
+    }
+
+    context.keymap.layer(() => ({
+      mode: "global",
+      priority: 10,
+      commands: [
+        {
+          id: "voice-dictation.tui.dictate",
+          title: "Dictar por voz",
+          description: "Abre el dictado de Windows (Win+H) en el prompt.",
+          group: "Voz",
+          bind: "<leader>d",
+          palette: true,
+          slash: { name: "dictado", aliases: ["dictate"] },
+          suggested: true,
+          run: dictate,
+        },
+        {
+          id: "voice-dictation.tui.read",
+          title: "Leer última respuesta",
+          description: "Lee en voz alta la última respuesta con voces Edge.",
+          group: "Voz",
+          bind: "<leader>v",
+          palette: true,
+          slash: { name: "leer", aliases: ["read"] },
+          suggested: true,
+          run: read,
+        },
+      ],
+      bindings: ["voice-dictation.tui.dictate", "voice-dictation.tui.read"],
+    }))
+
+    return () => stop()
+  },
+})