feat: voice stt ok english

scripts/transcribe.py

@@ -1,8 +1,8 @@
-import json, os, sys, tempfile, wave, struct
+import json, os, sys, tempfile, wave
 
 WAV_HEADER_SIZE = 44
 
-DEFAULT_MODEL_PATH = os.path.expanduser("~/.cache/huggingface/hub/models--Systran--faster-whisper-base")
+WHISPER_CACHE = os.path.expanduser("~/.cache/whisper")
 
 def write_wav(path: str, raw_pcm: bytes, sample_rate: int = 16000):
     with wave.open(path, 'wb') as w:
@@ -11,21 +11,25 @@ def write_wav(path: str, raw_pcm: bytes, sample_rate: int = 16000):
         w.setframerate(sample_rate)
         w.writeframes(raw_pcm)
 
-def resolve_model(model_size: str) -> str:
-    if os.path.isdir(model_size):
-        return model_size
-    local_path = os.path.expanduser(f"~/.cache/huggingface/hub/models--Systran--faster-whisper-{model_size}")
-    if os.path.isdir(local_path):
-        return local_path
-    return model_size
+def transcribe(wav_path: str, model_size: str = "large-v3-turbo", language: str | None = None) -> dict:
+    try:
+        import whisper
+        model = whisper.load_model(model_size, download_root=WHISPER_CACHE)
+        opts = {}
+        if language:
+            opts["language"] = language
+        result = model.transcribe(wav_path, **opts)
+        return {"success": True, "text": result["text"].strip(), "language": result.get("language", "")}
+    except ImportError:
+        pass
 
-def transcribe(wav_path: str, model_size: str = "base", language: str | None = None) -> dict:
-    model_path = resolve_model(model_size)
-    import sys as _sys
-    _sys.stderr.write(f"[DEBUG transcribe] model_path={model_path}\n")
-    _sys.stderr.flush()
     try:
         from faster_whisper import WhisperModel
+        model_path = model_size
+        if not os.path.isdir(model_path):
+            local_path = os.path.expanduser(f"~/.cache/huggingface/hub/models--Systran--faster-whisper-{model_size}")
+            if os.path.isdir(local_path):
+                model_path = local_path
         model = WhisperModel(model_path, device="cpu", compute_type="int8")
         opts = {"beam_size": 1}
         if language:
@@ -36,18 +40,7 @@ def transcribe(wav_path: str, model_size: str = "base", language: str | None = N
     except ImportError:
         pass
 
-    try:
-        import whisper
-        model = whisper.load_model(model_size)
-        opts = {}
-        if language:
-            opts["language"] = language
-        result = model.transcribe(wav_path, **opts)
-        return {"success": True, "text": result["text"].strip(), "language": result.get("language", "")}
-    except ImportError:
-        pass
-
-    return {"success": False, "error": "Neither faster-whisper nor openai-whisper is installed. Run: pip install faster-whisper"}
+    return {"success": False, "error": "Neither openai-whisper nor faster-whisper is installed. Run: pip install openai-whisper"}
 
 def main():
     if len(sys.argv) < 2:
@@ -55,7 +48,7 @@ def main():
         sys.exit(1)
 
     wav_path = sys.argv[1]
-    model_size = "base"
+    model_size = "large-v3-turbo"
     language = None
 
     i = 2
@@ -83,4 +76,4 @@ def main():
     print(json.dumps(result))
 
 if __name__ == "__main__":
-    main()
+    main()

src/hooks/useVoice.ts

@@ -89,6 +89,9 @@ const LANGUAGE_NAME_TO_CODE: Record<string, string> = {
   svenska: 'sv',
   norwegian: 'no',
   norsk: 'no',
+  chinese: 'zh',
+  中文: 'zh',
+  汉语: 'zh',
 }
 
 // Subset of the GrowthBook speech_to_text_voice_stream_config allowlist.
@@ -114,6 +117,7 @@ const SUPPORTED_LANGUAGE_CODES = new Set([
   'da',
   'sv',
   'no',
+  'zh',
 ])
 
 // Normalize a language preference string (from settings.language) to a

src/services/voice/edgeTTS.ts

@@ -1,14 +1,29 @@
 import { spawn } from 'child_process'
 import { existsSync } from 'fs'
 import { tmpdir } from 'os'
-import { join } from 'path'
+import { join, dirname } from 'path'
 
-const SCRIPTS_DIR = join(import.meta.dirname, '..', '..', '..', 'scripts')
+function findProjectRoot(): string {
+  let dir = process.cwd()
+  for (let i = 0; i < 20; i++) {
+    if (existsSync(join(dir, 'package.json')) && existsSync(join(dir, 'scripts'))) {
+      return dir
+    }
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return process.cwd()
+}
+
+const PROJECT_ROOT = findProjectRoot()
+const SCRIPTS_DIR = join(PROJECT_ROOT, 'scripts')
+const VENV_PYTHON = join(PROJECT_ROOT, '.venv', 'bin', 'python')
 
 function resolvePythonPath(customPath?: string): string {
   if (customPath) return customPath
-  const venvPython = join(import.meta.dirname, '..', '..', '..', '.venv', 'bin', 'python')
-  return existsSync(venvPython) ? venvPython : 'python3'
+  if (existsSync(VENV_PYTHON)) return VENV_PYTHON
+  return 'python3'
 }
 
 export type TTSResult = {

src/services/voice/whisperSTT.ts

@@ -1,21 +1,36 @@
 import { spawn } from 'child_process'
-import { appendFileSync, existsSync, mkdtempSync, writeFileSync, unlinkSync, rmdirSync } from 'fs'
+import { existsSync, mkdtempSync, writeFileSync, unlinkSync, rmdirSync } from 'fs'
 import { tmpdir } from 'os'
-import { join } from 'path'
+import { join, dirname } from 'path'
 import type { VoiceStreamCallbacks, VoiceStreamConnection, FinalizeSource } from '../voiceStreamSTT.js'
 
-const SCRIPTS_DIR = join(import.meta.dirname, '..', '..', '..', 'scripts')
-const DEBUG_LOG = '/tmp/voice_debug.log'
-const dbg = (...args: unknown[]) => {
-  const msg = args.map(a => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ')
-  const line = `[${new Date().toISOString()}] ${msg}\n`
-  appendFileSync(DEBUG_LOG, line)
+function findProjectRoot(): string {
+  let dir = process.cwd()
+  for (let i = 0; i < 20; i++) {
+    if (existsSync(join(dir, 'package.json')) && existsSync(join(dir, 'scripts'))) {
+      return dir
+    }
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return process.cwd()
+}
+
+const PROJECT_ROOT = findProjectRoot()
+const SCRIPTS_DIR = join(PROJECT_ROOT, 'scripts')
+const VENV_PYTHON = join(PROJECT_ROOT, '.venv', 'bin', 'python')
+
+const LOG = '/tmp/vc_whisper.log'
+function log(...args: unknown[]) {
+  const line = `[${new Date().toISOString()}] ${args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' ')}\n`
+  try { writeFileSync(LOG, line, { flag: 'a' }) } catch {}
 }
 
 function resolvePythonPath(customPath?: string): string {
   if (customPath) return customPath
-  const venvPython = join(import.meta.dirname, '..', '..', '..', '.venv', 'bin', 'python')
-  return existsSync(venvPython) ? venvPython : 'python3'
+  if (existsSync(VENV_PYTHON)) return VENV_PYTHON
+  return 'python3'
 }
 
 type WhisperOptions = {
@@ -24,16 +39,6 @@ type WhisperOptions = {
   pythonPath?: string
 }
 
-/**
- * A local Whisper STT provider that implements the VoiceStreamConnection
- * interface. Buffers incoming audio chunks, then on finalize() writes a
- * temporary WAV file and spawns a Python faster-whisper subprocess to
- * transcribe it.
- *
- * Requirements: pip install faster-whisper   (or openai-whisper)
- *
- * Whisper model files are cached at ~/.cache/whisper/ automatically.
- */
 export function connectLocalWhisperStream(
   callbacks: VoiceStreamCallbacks,
   options?: WhisperOptions,
@@ -44,34 +49,30 @@ export function connectLocalWhisperStream(
     let tmpDir: string | null = null
 
     const python = resolvePythonPath(options?.pythonPath)
-    const model = options?.model ?? 'base'
+    const model = options?.model ?? 'large-v3-turbo'
     const language = options?.language
-
-    dbg('whisperSTT', 'python', python, 'model', model, 'language', language)
+    log('projectRoot', PROJECT_ROOT, 'python', python, 'model', model, 'language', language)
 
     const connection: VoiceStreamConnection = {
       send(chunk: Buffer) {
         if (finalized) return
         chunks.push(Buffer.from(chunk))
-        if (chunks.length === 1) {
-          dbg('whisperSTT', 'first chunk', chunk.length, 'bytes')
-        }
+        if (chunks.length === 1) log('first chunk', chunk.length, 'bytes')
       },
 
       async finalize(): Promise<FinalizeSource> {
         if (finalized) return 'ws_already_closed'
         finalized = true
-
-        dbg('whisperSTT', 'finalize called, chunks', chunks.length)
+        log('finalize called, chunks', chunks.length)
 
         if (chunks.length === 0) {
-          dbg('whisperSTT', 'no audio chunks, returning no_data_timeout')
+          log('no chunks, returning no_data_timeout')
           callbacks.onClose()
           return 'no_data_timeout'
         }
 
         const audioBuf = Buffer.concat(chunks)
-        dbg('whisperSTT', 'total audio size', audioBuf.length, 'bytes')
+        log('total audio', audioBuf.length, 'bytes')
 
         try {
           tmpDir = mkdtempSync(join(tmpdir(), 'vc-whisper-'))
@@ -83,6 +84,7 @@ export function connectLocalWhisperStream(
           if (language) {
             args.push('--language', language)
           }
+          log('spawning', python, args.join(' '))
 
           const proc = spawn(python, args, { stdio: ['ignore', 'pipe', 'pipe'] })
 
@@ -101,7 +103,8 @@ export function connectLocalWhisperStream(
             proc.on('close', resolveExit)
           })
 
-          dbg('whisperSTT', 'subprocess exitCode', exitCode, 'stdout', stdout.slice(0, 200))
+          log('exitCode', exitCode, 'stdout', stdout.slice(0, 500), 'stderr', stderr.slice(0, 500))
+
           if (exitCode !== 0) {
             callbacks.onError(`Whisper transcription failed: ${stderr || 'unknown error'}`, {
               fatal: true,
@@ -111,8 +114,11 @@ export function connectLocalWhisperStream(
           }
 
           const result = JSON.parse(stdout)
-          if (result.success) {
+          log('result', result)
+          if (result.success && result.text) {
             callbacks.onTranscript(result.text, true)
+          } else if (result.success && !result.text) {
+            callbacks.onTranscript('', true)
           } else {
             callbacks.onError(
               result.error ?? 'Transcription failed',
@@ -128,14 +134,10 @@ export function connectLocalWhisperStream(
           if (tmpDir) {
             try {
               unlinkSync(join(tmpDir, 'input.wav'))
-            } catch {
-              // ignore
-            }
+            } catch {}
             try {
               rmdirSync(tmpDir)
-            } catch {
-              // ignore
-            }
+            } catch {}
           }
           callbacks.onClose()
         }
@@ -158,16 +160,15 @@ export function connectLocalWhisperStream(
   })
 }
 
-/** Check if a local whisper-capable Python installation exists. */
 export async function checkLocalWhisperAvailable(pythonPath?: string): Promise<boolean> {
   const python = resolvePythonPath(pythonPath)
   return new Promise(resolve => {
     const proc = spawn(python, [
       '-c',
       'import json;' +
-      'try: from faster_whisper import WhisperModel; print(json.dumps({"ok": True, "backend": "faster-whisper"}))' +
+      'try: import whisper; print(json.dumps({"ok": True, "backend": "whisper"}))' +
       'except ImportError:' +
-      '  try: import whisper; print(json.dumps({"ok": True, "backend": "whisper"}))' +
+      '  try: from faster_whisper import WhisperModel; print(json.dumps({"ok": True, "backend": "faster-whisper"}))' +
       '  except ImportError: print(json.dumps({"ok": False}))',
     ], { stdio: ['ignore', 'pipe', 'pipe'] })
 
@@ -184,7 +185,6 @@ export async function checkLocalWhisperAvailable(pythonPath?: string): Promise<b
   })
 }
 
-/** Write a valid PCM WAV file header and data. */
 function writeWavHeader(path: string, pcmData: Buffer, sampleRate: number): void {
   const numChannels = 1
   const bitsPerSample = 16
@@ -194,22 +194,19 @@ function writeWavHeader(path: string, pcmData: Buffer, sampleRate: number): void
 
   const header = Buffer.alloc(44)
 
-  // RIFF header
   header.write('RIFF', 0)
   header.writeUInt32LE(36 + dataSize, 4)
   header.write('WAVE', 8)
 
-  // fmt chunk
   header.write('fmt ', 12)
-  header.writeUInt32LE(16, 16) // chunk size
-  header.writeUInt16LE(1, 20)  // PCM format
+  header.writeUInt32LE(16, 16)
+  header.writeUInt16LE(1, 20)
   header.writeUInt16LE(numChannels, 22)
   header.writeUInt32LE(sampleRate, 24)
   header.writeUInt32LE(byteRate, 28)
   header.writeUInt16LE(blockAlign, 32)
   header.writeUInt16LE(bitsPerSample, 34)
 
-  // data chunk
   header.write('data', 36)
   header.writeUInt32LE(dataSize, 40)