opencode-voice 0.1.0

package/src/index.ts

@@ -0,0 +1,177 @@
+/* biome-ignore-all assist/source/organizeImports: keep runtime and type imports grouped for clarity */
+import { createSignal } from "solid-js";
+import type { PluginOptions } from "@opencode-ai/plugin";
+import type {
+  TuiPlugin,
+  TuiPluginApi,
+  TuiPluginMeta,
+  TuiPluginModule,
+  TuiSlotPlugin,
+} from "@opencode-ai/plugin/tui";
+
+import { loadVoiceConfig, resolveApiKey } from "./config";
+import { detectRecordingTool, getInstallInstructions } from "./audio/detector";
+import { Recorder } from "./audio/recorder";
+import { createProvider } from "./providers/factory";
+import { VoiceSession } from "./session";
+import { RecordingIndicator } from "./ui/recording-indicator";
+import type { TranscriptionEvent, VoiceSessionState } from "./types";
+
+const VOICE_COMMAND_KEYBIND = "ctrl+shift+v";
+const VOICE_COMMAND_VALUE = "voice-toggle";
+
+type PluginDeps = {
+  loadVoiceConfig: typeof loadVoiceConfig;
+  resolveApiKey: typeof resolveApiKey;
+  detectRecordingTool: typeof detectRecordingTool;
+  getInstallInstructions: typeof getInstallInstructions;
+  Recorder: typeof Recorder;
+  createProvider: typeof createProvider;
+  VoiceSession: typeof VoiceSession;
+  RecordingIndicator: typeof RecordingIndicator;
+};
+
+const defaultDeps: PluginDeps = {
+  loadVoiceConfig,
+  resolveApiKey,
+  detectRecordingTool,
+  getInstallInstructions,
+  Recorder,
+  createProvider,
+  VoiceSession,
+  RecordingIndicator,
+};
+
+async function appendTranscript(
+  api: TuiPluginApi,
+  text: string,
+): Promise<void> {
+  await api.client.tui.appendPrompt({ text: `${text} ` });
+}
+
+export function createTuiPlugin(deps: PluginDeps = defaultDeps): TuiPlugin {
+  return async (
+    api: TuiPluginApi,
+    options: PluginOptions | undefined,
+    _meta: TuiPluginMeta,
+  ): Promise<void> => {
+    let config: ReturnType<typeof loadVoiceConfig>;
+    try {
+      config = deps.loadVoiceConfig(options);
+    } catch (error) {
+      api.ui.toast({
+        variant: "error",
+        title: "opencode-voice",
+        message: error instanceof Error ? error.message : "Configuration error",
+      });
+      return;
+    }
+
+    const detected = await deps.detectRecordingTool();
+    if (!detected) {
+      api.ui.toast({
+        variant: "error",
+        title: "opencode-voice",
+        message:
+          "No recording tool found. Install sox to use voice input.\n" +
+          deps.getInstallInstructions(process.platform),
+      });
+      return;
+    }
+
+    const recorder = new deps.Recorder(detected.tool, detected.path);
+    const provider = deps.createProvider(config);
+    const apiKey = deps.resolveApiKey(config.provider);
+    const [isRecording, setIsRecording] = createSignal(false);
+    const [interimText, setInterimText] = createSignal("");
+
+    const session = new deps.VoiceSession({
+      recorder,
+      provider,
+      providerConfig: {
+        apiKey,
+        language: config.language,
+      },
+      onTranscript: (event: TranscriptionEvent) => {
+        if (event.isFinal) {
+          setInterimText("");
+          void appendTranscript(api, event.text);
+          return;
+        }
+
+        setInterimText(event.text);
+      },
+      onStateChange: (state: VoiceSessionState) => {
+        setIsRecording(state === "recording");
+      },
+      onError: (error: Error) => {
+        api.ui.toast({
+          variant: "error",
+          title: "Voice Error",
+          message: error.message,
+        });
+      },
+    });
+
+    const unregisterCommand = api.command.register(() => [
+      {
+        title: "Toggle Voice Recording",
+        value: VOICE_COMMAND_VALUE,
+        description: "Start/stop voice-to-text recording (Ctrl+Shift+V)",
+        keybind: VOICE_COMMAND_KEYBIND,
+        hidden: true,
+        onSelect: () => {
+          void (async () => {
+            const before = session.getState();
+            await session.toggle();
+            const after = session.getState();
+
+            if (before === after) {
+              return;
+            }
+
+            if (after === "recording") {
+              api.ui.toast({
+                variant: "info",
+                title: "Voice",
+                message: "Recording started... Ctrl+Shift+V to stop",
+              });
+              return;
+            }
+
+            if (before === "recording") {
+              api.ui.toast({
+                variant: "info",
+                title: "Voice",
+                message: "Recording stopped",
+              });
+            }
+          })();
+        },
+      },
+    ]);
+
+    const slotPlugin: TuiSlotPlugin = {
+      slots: {
+        home_bottom: () =>
+          deps.RecordingIndicator({
+            isRecording,
+            interimText,
+          }),
+      },
+    };
+
+    api.slots.register(slotPlugin);
+
+    api.lifecycle.onDispose(async () => {
+      unregisterCommand();
+      await session.dispose();
+    });
+  };
+}
+
+export const tui = createTuiPlugin();
+
+const plugin: TuiPluginModule = { tui };
+
+export default plugin;

package/src/providers/chunked.ts

@@ -0,0 +1,143 @@
+import type {
+  ProviderConfig,
+  TranscriptionEvent,
+  TranscriptionProvider,
+  VoiceProvider,
+} from "../types";
+
+type ChunkedConfig = {
+  chunkDurationMs?: number;
+  overlapMs?: number;
+};
+
+const BYTES_PER_MS = 32;
+
+export abstract class ChunkedProvider implements TranscriptionProvider {
+  abstract readonly name: VoiceProvider;
+
+  private transcriptCallback: ((event: TranscriptionEvent) => void) | null =
+    null;
+  private errorCallback: ((err: Error) => void) | null = null;
+  private audioBuffer: Uint8Array[] = [];
+  private chunkTimer: ReturnType<typeof setInterval> | null = null;
+  private previousTranscript = "";
+  private connected = false;
+  private hasUnprocessedAudio = false;
+  protected providerConfig: ProviderConfig = {};
+
+  private readonly chunkDurationMs: number;
+  private readonly overlapMs: number;
+
+  constructor(config?: ChunkedConfig) {
+    this.chunkDurationMs = config?.chunkDurationMs ?? 5000;
+    this.overlapMs = config?.overlapMs ?? 500;
+  }
+
+  async connect(config: ProviderConfig): Promise<void> {
+    this.stopChunkTimer();
+    this.providerConfig = config;
+    this.audioBuffer = [];
+    this.previousTranscript = "";
+    this.connected = true;
+    this.hasUnprocessedAudio = false;
+    this.startChunkTimer();
+  }
+
+  sendAudio(chunk: Uint8Array): void {
+    if (!this.connected) {
+      return;
+    }
+
+    this.audioBuffer.push(chunk);
+    this.hasUnprocessedAudio = true;
+  }
+
+  onTranscript(callback: (event: TranscriptionEvent) => void): void {
+    this.transcriptCallback = callback;
+  }
+
+  onError(callback: (err: Error) => void): void {
+    this.errorCallback = callback;
+  }
+
+  async disconnect(): Promise<void> {
+    this.connected = false;
+    this.stopChunkTimer();
+
+    if (this.hasUnprocessedAudio && this.audioBuffer.length > 0) {
+      await this.processChunk();
+    }
+  }
+
+  private startChunkTimer(): void {
+    this.chunkTimer = setInterval(async () => {
+      if (this.hasUnprocessedAudio && this.audioBuffer.length > 0) {
+        await this.processChunk();
+      }
+    }, this.chunkDurationMs);
+  }
+
+  private stopChunkTimer(): void {
+    if (this.chunkTimer !== null) {
+      clearInterval(this.chunkTimer);
+      this.chunkTimer = null;
+    }
+  }
+
+  private async processChunk(): Promise<void> {
+    if (this.audioBuffer.length === 0) {
+      return;
+    }
+
+    const totalLength = this.audioBuffer.reduce(
+      (sum, chunk) => sum + chunk.length,
+      0,
+    );
+    const audio = new Uint8Array(totalLength);
+    let offset = 0;
+
+    for (const chunk of this.audioBuffer) {
+      audio.set(chunk, offset);
+      offset += chunk.length;
+    }
+
+    const overlapBytes = this.overlapMs * BYTES_PER_MS;
+    if (audio.length > overlapBytes) {
+      this.audioBuffer = [audio.slice(audio.length - overlapBytes)];
+    } else {
+      this.audioBuffer = [];
+    }
+    this.hasUnprocessedAudio = false;
+
+    let lastError: Error | null = null;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const text = await this.transcribeChunk(audio, this.previousTranscript);
+
+        if (text.trim()) {
+          this.previousTranscript = text;
+          this.transcriptCallback?.({ text, isFinal: true });
+        }
+
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+
+        if (attempt < 2) {
+          await new Promise((resolve) =>
+            setTimeout(resolve, 500 * 2 ** attempt),
+          );
+        }
+      }
+    }
+
+    this.errorCallback?.(
+      lastError ?? new Error("Transcription failed after 3 attempts"),
+    );
+  }
+
+  protected abstract transcribeChunk(
+    audio: Uint8Array,
+    previousTranscript: string,
+  ): Promise<string>;
+}

package/src/providers/deepgram.ts

@@ -0,0 +1,74 @@
+import { StreamingProvider } from "./streaming";
+import type {
+  VoiceProvider,
+  ProviderConfig,
+  TranscriptionEvent,
+} from "../types";
+import { AuthError } from "../types";
+
+export class DeepgramProvider extends StreamingProvider {
+  readonly name: VoiceProvider = "deepgram";
+
+  constructor() {
+    super({ keepaliveIntervalMs: 8000, reconnectMaxRetries: 3 });
+  }
+
+  protected createWebSocket(config: ProviderConfig): WebSocket {
+    const apiKey = config.apiKey;
+    if (!apiKey)
+      throw new AuthError(
+        "Deepgram API key not configured. Set DEEPGRAM_API_KEY env var.",
+      );
+
+    const language = (config.language as string) ?? "";
+    const model = (config.model as string) ?? "nova-2";
+
+    const params = new URLSearchParams({
+      model,
+      interim_results: "true",
+      punctuate: "true",
+      vad_events: "true",
+      encoding: "linear16",
+      sample_rate: "16000",
+      channels: "1",
+    });
+    if (language) params.set("language", language);
+
+    const url = `wss://api.deepgram.com/v1/listen?${params.toString()}`;
+
+    // Bun's WebSocket supports headers in the constructor options
+    return new WebSocket(url, {
+      headers: { Authorization: `Token ${apiKey}` },
+    } as any);
+  }
+
+  protected parseMessage(data: unknown): TranscriptionEvent | null {
+    if (typeof data !== "string") return null;
+
+    let parsed: any;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      return null;
+    }
+
+    // Only handle Results messages with non-empty transcripts
+    if (parsed.type !== "Results") return null;
+
+    const transcript = parsed.channel?.alternatives?.[0]?.transcript;
+    if (!transcript || transcript.trim() === "") return null;
+
+    const confidence = parsed.channel?.alternatives?.[0]?.confidence;
+    const isFinal = parsed.is_final === true || parsed.speech_final === true;
+
+    return {
+      text: transcript,
+      isFinal,
+      confidence: typeof confidence === "number" ? confidence : undefined,
+    };
+  }
+
+  protected buildKeepAliveFrame(): string {
+    return JSON.stringify({ type: "KeepAlive" });
+  }
+}

package/src/providers/factory.ts

@@ -0,0 +1,20 @@
+import type { TranscriptionProvider, VoiceConfig } from "../types.ts";
+import { ConfigError } from "../types.ts";
+import { GroqProvider } from "./groq.ts";
+import { OpenAIWhisperProvider } from "./openai.ts";
+import { DeepgramProvider } from "./deepgram.ts";
+
+export function createProvider(config: VoiceConfig): TranscriptionProvider {
+  switch (config.provider) {
+    case "groq":
+      return new GroqProvider(config.chunkDurationMs);
+    case "openai-whisper":
+      return new OpenAIWhisperProvider(config.chunkDurationMs);
+    case "deepgram":
+      return new DeepgramProvider();
+    default:
+      throw new ConfigError(
+        `Unknown provider: "${(config as any).provider}". Valid providers: groq, openai-whisper, deepgram`,
+      );
+  }
+}

package/src/providers/groq.ts

@@ -0,0 +1,57 @@
+import { ChunkedProvider } from "./chunked.ts";
+import { AuthError, RateLimitError, ProviderError } from "../types.ts";
+import type { VoiceProvider } from "../types.ts";
+import { wrapInWav } from "./wav-utils.ts";
+
+export class GroqProvider extends ChunkedProvider {
+  readonly name: VoiceProvider = "groq";
+
+  constructor(chunkDurationMs = 5000) {
+    super({ chunkDurationMs, overlapMs: 500 });
+  }
+
+  protected async transcribeChunk(
+    audio: Uint8Array,
+    previousTranscript: string,
+  ): Promise<string> {
+    const apiKey = this.providerConfig.apiKey;
+    if (!apiKey)
+      throw new AuthError(
+        "Groq API key not configured. Set GROQ_API_KEY env var.",
+      );
+
+    const model = (this.providerConfig.model as string) ?? "whisper-large-v3";
+    const language = this.providerConfig.language as string | undefined;
+
+    const wav = wrapInWav(audio);
+    const formData = new FormData();
+    formData.append(
+      "file",
+      new Blob([wav.buffer as ArrayBuffer], { type: "audio/wav" }),
+      "audio.wav",
+    );
+    formData.append("model", model);
+    formData.append("response_format", "text");
+    if (previousTranscript) formData.append("prompt", previousTranscript);
+    if (language) formData.append("language", language);
+
+    const response = await fetch(
+      "https://api.groq.com/openai/v1/audio/transcriptions",
+      {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}` },
+        body: formData,
+      },
+    );
+
+    if (response.status === 401) throw new AuthError("Invalid Groq API key.");
+    if (response.status === 429)
+      throw new RateLimitError("Groq rate limit exceeded.");
+    if (!response.ok)
+      throw new ProviderError(
+        `Groq API error: ${response.status} ${response.statusText}`,
+      );
+
+    return (await response.text()).trim();
+  }
+}

package/src/providers/openai.ts

@@ -0,0 +1,57 @@
+import { ChunkedProvider } from "./chunked.ts";
+import { AuthError, RateLimitError, ProviderError } from "../types.ts";
+import type { VoiceProvider } from "../types.ts";
+import { wrapInWav } from "./wav-utils.ts";
+
+export class OpenAIWhisperProvider extends ChunkedProvider {
+  readonly name: VoiceProvider = "openai-whisper";
+
+  constructor(chunkDurationMs = 10000) {
+    super({ chunkDurationMs, overlapMs: 500 });
+  }
+
+  protected async transcribeChunk(
+    audio: Uint8Array,
+    previousTranscript: string,
+  ): Promise<string> {
+    const apiKey = this.providerConfig.apiKey;
+    if (!apiKey)
+      throw new AuthError(
+        "OpenAI API key not configured. Set OPENAI_API_KEY env var.",
+      );
+
+    const model = (this.providerConfig.model as string) ?? "whisper-1";
+    const language = this.providerConfig.language as string | undefined;
+
+    const wav = wrapInWav(audio);
+    const formData = new FormData();
+    formData.append(
+      "file",
+      new Blob([wav], { type: "audio/wav" }),
+      "audio.wav",
+    );
+    formData.append("model", model);
+    formData.append("response_format", "text");
+    if (previousTranscript) formData.append("prompt", previousTranscript);
+    if (language) formData.append("language", language);
+
+    const response = await fetch(
+      "https://api.openai.com/v1/audio/transcriptions",
+      {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}` },
+        body: formData,
+      },
+    );
+
+    if (response.status === 401) throw new AuthError("Invalid OpenAI API key.");
+    if (response.status === 429)
+      throw new RateLimitError("OpenAI rate limit exceeded.");
+    if (!response.ok)
+      throw new ProviderError(
+        `OpenAI API error: ${response.status} ${response.statusText}`,
+      );
+
+    return (await response.text()).trim();
+  }
+}