opencode-voice-dictation 0.0.0-stage → 0.1.0

package/src/gui/speak.ts

@@ -0,0 +1,260 @@
+import { createSignal } from "solid-js"
+import type { IpcClient, SetupContext } from "@opencode/plugin/gui"
+import { Speech } from "./contract"
+import type { definition } from "./definition"
+
+export interface VoiceOption {
+  id: string
+  label: string
+}
+
+export interface Speaker {
+  speaking(): boolean
+  backend(): "web" | "sapi" | "none"
+  voices(): VoiceOption[]
+  refreshVoices(): Promise<void>
+  lastAssistantText(): Promise<string>
+  speak(text: string): Promise<boolean>
+  cancel(): void
+  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 function createSpeaker(
+  ctx: SetupContext<typeof definition>,
+  speech: IpcClient<typeof Speech.spec>,
+): Speaker {
+  const prefs = ctx.stores.speech
+
+  const [speaking, setSpeaking] = createSignal(false)
+  const [voices, setVoices] = createSignal<VoiceOption[]>([])
+  const [backend, setBackend] = createSignal<"web" | "sapi" | "none">("none")
+
+  let generation = 0
+  let queue: string[] = []
+
+  const synth = () =>
+    typeof globalThis.speechSynthesis !== "undefined" ? globalThis.speechSynthesis : undefined
+
+  const pickVoice = () => {
+    const available = synth()?.getVoices() ?? []
+    if (available.length === 0) return undefined
+
+    const wanted = prefs.value.voiceURI
+    if (wanted) {
+      const chosen = available.find((voice) => voice.voiceURI === wanted)
+      if (chosen) return chosen
+    }
+
+    const base = ctx.locale.locale().split("-")[0]?.toLowerCase() ?? "es"
+    return available.find((voice) => voice.lang.toLowerCase().startsWith(base)) ?? available[0]
+  }
+
+  const refreshVoices = async () => {
+    const available = synth()?.getVoices() ?? []
+
+    if (available.length > 0) {
+      setVoices(
+        available.map((voice) => ({
+          id: voice.voiceURI,
+          label: `${voice.name} — ${voice.lang}`,
+        })),
+      )
+      setBackend("web")
+      return
+    }
+
+    try {
+      const names = await speech.voices()
+      if (names.length > 0) {
+        setVoices(names.map((name) => ({ id: name, label: name })))
+        setBackend("sapi")
+        return
+      }
+    } catch {
+      // Main is unreachable or PowerShell failed; treat as no voices.
+    }
+
+    setBackend("none")
+  }
+
+  const cancel = () => {
+    generation++
+    queue = []
+    synth()?.cancel()
+    setSpeaking(false)
+    void speech.stop().catch(() => {})
+  }
+
+  const speak = async (text: string) => {
+    const cleaned = cleanForSpeech(text, prefs.value.skipCode)
+    if (!cleaned) return false
+
+    cancel()
+    await refreshVoices()
+
+    if (backend() === "web") {
+      const engine = synth()
+      if (!engine) return false
+
+      const voice = pickVoice()
+      const rate = prefs.value.rate
+      const gen = generation
+      queue = chunkForSpeech(cleaned)
+      setSpeaking(true)
+
+      const pump = () => {
+        if (gen !== generation) return
+        const next = queue.shift()
+        if (!next) {
+          setSpeaking(false)
+          return
+        }
+
+        const utterance = new SpeechSynthesisUtterance(next)
+        if (voice) utterance.voice = voice
+        if (voice?.lang) utterance.lang = voice.lang
+        utterance.rate = rate
+        utterance.onend = pump
+        utterance.onerror = pump
+        engine.speak(utterance)
+      }
+
+      pump()
+      return true
+    }
+
+    if (backend() === "sapi") {
+      setSpeaking(true)
+      try {
+        await speech.speak({
+          text: cleaned,
+          rate: prefs.value.rate,
+          voice: prefs.value.voiceURI,
+        })
+      } catch (cause) {
+        setSpeaking(false)
+        throw cause
+      }
+      return true
+    }
+
+    setSpeaking(false)
+    throw new Error(ctx.t("read.noVoices"))
+  }
+
+  const lastAssistantText = async () => {
+    const session = ctx.sessions.current()
+    if (!session) return ""
+
+    // The session may live on another server than the one that runs the plugin
+    // (the desktop app can show WSL and Windows servers side by side), so ask
+    // the session's own server instead of `ctx.client`.
+    const page = await session.server.client.message.list({
+      sessionID: session.id,
+      type: "assistant",
+      order: "desc",
+      limit: 1,
+    })
+
+    const message = page.data[0]
+    if (!message || message.type !== "assistant") return ""
+
+    return message.content
+      .filter((part) => part.type === "text")
+      .map((part) => part.text)
+      .join("\n")
+  }
+
+  speech.on("done", () => setSpeaking(false))
+
+  const engine = synth()
+  engine?.addEventListener?.("voiceschanged", () => void refreshVoices())
+  void refreshVoices()
+
+  return {
+    speaking,
+    backend,
+    voices,
+    refreshVoices,
+    lastAssistantText,
+    speak,
+    cancel,
+    preview: () => speak(ctx.t("speech.preview.text")),
+  }
+}

package/src/gui/window.tsx

@@ -0,0 +1,239 @@
+import { Command, ComposerPill, SettingsPage, type ComposerPillView, type Plugin } from "@opencode/plugin/gui"
+import { Dictation, Speech } from "./contract"
+import type { definition } from "./definition"
+import { createSpeaker } from "./speak"
+import { VoiceSettings } from "./settings"
+
+/**
+ * Window setup: the microphone pill above the composer, the keybind and the
+ * `/dictado` slash command.
+ */
+export const setup: Plugin.Setup<typeof definition> = (ctx) => {
+  const dictation = ctx.main(Dictation)
+  const speech = ctx.main(Speech)
+  const speaker = createSpeaker(ctx, speech)
+  const prefs = ctx.stores.prefs
+
+  let targetSession: string | undefined
+
+  const reason = (code: string, detail: string, available: readonly string[]) => {
+    switch (code) {
+      case "LANGUAGE_NOT_AVAILABLE":
+        return ctx.t("error.language", {
+          locale: detail || prefs.value.locale,
+          available: available.length > 0 ? available.join(", ") : "—",
+        })
+      case "NO_RECOGNIZERS":
+        return ctx.t("error.none")
+      case "MICROPHONE_UNAVAILABLE":
+        return ctx.t("error.mic")
+      case "SYSTEM_SPEECH_UNAVAILABLE":
+        return ctx.t("error.system")
+      case "ENGINE_EXIT":
+        return ctx.t("error.exit")
+      default:
+        return ctx.t("error.unknown", { code })
+    }
+  }
+
+  const start = () => {
+    speaker.cancel()
+    targetSession = ctx.sessions.current()?.key
+    void dictation
+      .start({ locale: prefs.value.locale, minConfidence: prefs.value.minConfidence })
+      .catch((cause: unknown) => {
+        ctx.toast.show({
+          variant: "error",
+          title: ctx.t("error.title"),
+          description: cause instanceof Error ? cause.message : String(cause),
+        })
+      })
+  }
+
+  const stop = () => {
+    void dictation.stop().catch(() => {})
+  }
+
+  const toggle = () => {
+    const status = dictation.state()?.status ?? "idle"
+    if (status === "starting" || status === "listening") stop()
+    else start()
+  }
+
+  const read = () => {
+    if (speaker.speaking()) {
+      speaker.cancel()
+      return
+    }
+
+    if (!ctx.sessions.current()) {
+      ctx.toast.show({ variant: "error", title: ctx.t("read.title"), description: ctx.t("read.noSession") })
+      return
+    }
+
+    const status = dictation.state()?.status ?? "idle"
+    if (status === "starting" || status === "listening") void dictation.stop().catch(() => {})
+
+    void (async () => {
+      try {
+        const text = await speaker.lastAssistantText()
+        if (!text.trim()) {
+          ctx.toast.show({ variant: "default", title: ctx.t("read.title"), description: ctx.t("read.empty") })
+          return
+        }
+        const started = await speaker.speak(text)
+        if (!started) {
+          ctx.toast.show({ variant: "default", title: ctx.t("read.title"), description: ctx.t("read.empty") })
+        }
+      } catch (cause) {
+        ctx.toast.show({
+          variant: "error",
+          title: ctx.t("read.title"),
+          description: cause instanceof Error ? cause.message : ctx.t("read.error"),
+        })
+      }
+    })()
+  }
+
+  dictation.on("final", (data) => {
+    const current = ctx.sessions.current()?.key
+
+    if (targetSession && current && current !== targetSession) {
+      ctx.toast.show({ variant: "error", title: ctx.t("error.title"), description: ctx.t("toast.discarded") })
+      return
+    }
+
+    const composer = ctx.screen.current()?.composer
+    if (!composer) return
+
+    const existing = composer.text()
+    const separator = prefs.value.trailingSpace && existing.length > 0 && !/\s$/.test(existing) ? " " : ""
+    composer.insert(separator + data.text)
+
+    if (prefs.value.autoFocus) composer.focus()
+  })
+
+  dictation.on("error", (data) => {
+    ctx.toast.show({
+      variant: "error",
+      title: ctx.t("error.title"),
+      description: reason(data.code, data.detail, data.available),
+      persistent: data.code === "LANGUAGE_NOT_AVAILABLE" || data.code === "NO_RECOGNIZERS",
+      duration: 8000,
+    })
+  })
+
+  const view = (): ComposerPillView | undefined => {
+    if (ctx.app.platform !== "desktop") return undefined
+
+    const status = dictation.state()?.status ?? "idle"
+
+    if (status === "starting") {
+      return { label: ctx.t("pill.starting"), icon: "outline-wave-audio", title: ctx.t("pill.title"), run: toggle }
+    }
+
+    if (status === "listening") {
+      return {
+        label: ctx.t("pill.listening"),
+        icon: "outline-wave-audio",
+        tone: "danger",
+        title: ctx.t("pill.stop"),
+        run: toggle,
+      }
+    }
+
+    if (status === "error") {
+      return {
+        label: ctx.t("pill.error"),
+        icon: "outline-wave-audio",
+        tone: "warning",
+        title: ctx.t("pill.title"),
+        run: toggle,
+      }
+    }
+
+    return { label: ctx.t("pill.idle"), icon: "outline-wave-audio", title: ctx.t("pill.title"), run: toggle }
+  }
+
+  ctx.add(ComposerPill, () => ({ id: "dictate", show: () => view() }))
+
+  ctx.add(ComposerPill, () => ({
+    id: "read",
+    order: 1,
+    show: () => {
+      if (ctx.app.platform !== "desktop") return undefined
+
+      return speaker.speaking()
+        ? {
+            label: ctx.t("read.speaking"),
+            icon: "outline-audio",
+            tone: "success",
+            title: ctx.t("read.stop"),
+            run: read,
+          }
+        : {
+            label: ctx.t("read.idle"),
+            icon: "outline-audio",
+            title: ctx.t("read.title"),
+            run: read,
+          }
+    },
+  }))
+
+  ctx.add(Command, (): Command => ({
+    id: "toggle",
+    title: ctx.t("command.toggle"),
+    description: ctx.t("command.toggle.description"),
+    keywords: "voice dictation microphone speech dictado voz microfono",
+    group: ctx.t("pill.title"),
+    section: "prompt",
+    bind: "mod+shift+m",
+    slash: { name: "dictado" },
+    editable: true,
+    enabled: ctx.app.platform === "desktop",
+    run: toggle,
+  }))
+
+  ctx.add(Command, (): Command => ({
+    id: "configure",
+    title: ctx.t("command.configure"),
+    keywords: "voice dictation microphone speech dictado voz microfono",
+    group: ctx.t("pill.title"),
+    enabled: ctx.app.platform === "desktop",
+    run: () => ctx.layout.settings(ctx.id),
+  }))
+
+  ctx.add(Command, (): Command => ({
+    id: "read",
+    title: ctx.t("command.read"),
+    description: ctx.t("command.read.description"),
+    keywords: "read aloud speech voice leer voz altavoz lectura",
+    group: ctx.t("pill.title"),
+    section: "prompt",
+    bind: "mod+shift+l",
+    slash: { name: "leer" },
+    editable: true,
+    enabled: ctx.app.platform === "desktop",
+    run: read,
+  }))
+
+  ctx.add(SettingsPage, {
+    id: ctx.id,
+    icon: "outline-audio",
+    get title() {
+      return ctx.t("settings.title")
+    },
+    get entries() {
+      return [
+        { id: "language", title: ctx.t("settings.language"), keywords: "voice language idioma voz" },
+        { id: "confidence", title: ctx.t("settings.confidence"), keywords: "voice confidence confianza" },
+        { id: "test", title: ctx.t("settings.test"), keywords: "voice microphone microphone test microfono" },
+        { id: "voice", title: ctx.t("speech.voice"), keywords: "read aloud voice voz lectura altavoz" },
+        { 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" },
+      ]
+    },
+    render: () => <VoiceSettings speaker={speaker} />,
+  })
+}

package/src/gui.tsx

@@ -0,0 +1,6 @@
+import { Plugin } from "@opencode/plugin/gui"
+import { definition } from "./gui/definition"
+import { main } from "./gui/main"
+import { setup } from "./gui/window"
+
+export default Plugin.define({ ...definition, setup, main })

package/src/index.ts

@@ -0,0 +1,19 @@
+import type { Plugin } from "@opencode/plugin"
+
+/**
+ * Server part of the plugin.
+ *
+ * It does nothing on its own: it exists so the desktop app assigns the plugin
+ * the id `voice-dictation` (used for commands, settings pages and the Ipc
+ * contract) and so the GUI part is loaded from the global `opencode.json`.
+ *
+ * `@opencode/plugin` is a type-only import on purpose: the server loads this
+ * file directly, and a runtime import would make the plugin depend on a
+ * `node_modules` tree next to it.
+ */
+const plugin: Plugin.Plugin = {
+  id: "voice-dictation",
+  setup() {},
+}
+
+export default plugin