From 1dcf62a1bbad4fd3559ffa62bf6155df3e0e871c Mon Sep 17 00:00:00 2001 From: Wisley Alves Date: Fri, 13 Nov 2026 17:55:11 -0300 Subject: [PATCH] fix(voz): voz local sem pausas entre os trechos e frase de enviar mais tolerante MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Kokoro: um processo por leitura (--serve), o modelo carrega uma vez só. - Os trechos são gerados sem parar, adiantando enquanto o atual toca; na voz local crescem 25% por trecho (80 → 600), pra cada um ficar pronto antes do anterior acabar. - Parar a leitura encerra a voz local na hora. - "term7 pronto" aceita mais grafias do Whisper ("Tens 7", "Thermo 7", "Ternset", "Term 7pronto", "pronta"), sempre exigindo o número logo depois. Co-Authored-By: Claude Opus 5.5 --- extensions/README.md | 5 +- extensions/README.pt-BR.md | 4 +- extensions/kokoro/term7-kokoro | 41 ++++- extensions/kokoro/test_term7_kokoro.py | 17 ++ src-tauri/src/speech.rs | 246 ++++++++++++++----------- src/lib/voice.test.ts | 6 +- src/lib/voice.ts | 20 +- 7 files changed, 212 insertions(+), 127 deletions(-) diff --git a/extensions/README.md b/extensions/README.md index 0daede8..6ada5eb 100644 --- a/extensions/README.md +++ b/extensions/README.md @@ -78,7 +78,8 @@ statusbot every minute. While term7 is closed, it just tries again on the next r Reads Claude's replies aloud with [Kokoro-82M](https://github.com/thewh1teagle/kokoro-onnx), generated on your own machine: no internet, no quota, and the text never leaves the computer. Unlike the others, this extension doesn't use -the API: term7 itself calls it for each chunk of the reply. +the API: term7 opens it once per reading (`--serve`), so the model loads once and the next chunks are generated +while the current one plays. Install it from the screen (Settings → Extensions → Local voice). Installing creates a venv in `~/.local/share/term7/kokoro` with `kokoro-onnx` and downloads the int8 model (~120 MB). Then, in Settings → Read @@ -88,7 +89,7 @@ aloud, pick “Local voice (extension)”. the English voices (`af_heart`, `am_michael`…). - **Speed:** 1.0 is normal; 0.8 speaks slower. - **CPU cores:** how many to use while generating (default 4). Each reply read aloud keeps the CPU busy for a few - seconds. + seconds. With 1 core generation barely keeps up with speech; use 2 or more if you hear pauses. - Try it outside term7: `echo "Hello" | python3 /usr/share/term7/extensions/kokoro/term7-kokoro /tmp/hello.wav` - Remove: from the screen, or delete `~/.local/share/term7/kokoro` and `~/.config/term7/kokoro.env`. diff --git a/extensions/README.pt-BR.md b/extensions/README.pt-BR.md index 4c4d001..1bf4e7a 100644 --- a/extensions/README.pt-BR.md +++ b/extensions/README.pt-BR.md @@ -79,7 +79,8 @@ a cada minuto. Com o term7 fechado, ele só tenta de novo na volta seguinte. Lê as respostas do Claude em voz alta com o [Kokoro-82M](https://github.com/thewh1teagle/kokoro-onnx), gerado na própria máquina: sem internet, sem cota e sem o texto sair do computador. Diferente das outras, essa extensão não usa a -API: quem chama é o próprio term7, a cada trecho da resposta. +API: o term7 abre ela uma vez por leitura (`--serve`), então o modelo carrega uma vez só e os próximos trechos são +gerados enquanto o atual toca. Instale pela tela (Configurações → Extensões → Voz local). A instalação cria um venv em `~/.local/share/term7/kokoro` com o `kokoro-onnx` e baixa o modelo int8 (~120 MB). Depois, em Configurações → Leitura em voz alta, escolha @@ -89,6 +90,7 @@ com o `kokoro-onnx` e baixa o modelo int8 (~120 MB). Depois, em Configurações (`af_heart`, `am_michael`…). - **Velocidade:** 1.0 é o normal; 0.8 fala mais devagar. - **Núcleos da CPU:** quantos usar pra gerar (padrão 4). Cada resposta lida ocupa a CPU por alguns segundos. + Com 1 núcleo a geração fica quase no ritmo da fala; use 2 ou mais se ouvir pausas. - Testar fora do term7: `echo "Olá" | python3 /usr/share/term7/extensions/kokoro/term7-kokoro /tmp/ola.wav` - Remover: pela tela, ou apagar `~/.local/share/term7/kokoro` e `~/.config/term7/kokoro.env`. diff --git a/extensions/kokoro/term7-kokoro b/extensions/kokoro/term7-kokoro index 017bb7f..97319a0 100755 --- a/extensions/kokoro/term7-kokoro +++ b/extensions/kokoro/term7-kokoro @@ -4,7 +4,10 @@ Gera a fala na própria máquina com o Kokoro-82M (int8, via kokoro-onnx): nada sai da máquina e não tem cota. O term7 chama uma vez por trecho: - term7-kokoro OUT.wav < texto gera o .wav do texto + term7-kokoro --serve fica aberto durante a leitura: carrega o modelo + uma vez; cada linha {"text", "out"} no stdin + vira um .wav e responde "ok" (ou "erro: ...") + term7-kokoro OUT.wav < texto gera um .wav só (pra testar na mão) term7-kokoro --setup cria o ambiente e baixa o modelo (~120 MB) As dependências (kokoro-onnx, onnxruntime) ficam num venv próprio em @@ -18,6 +21,7 @@ Configuração ($XDG_CONFIG_HOME/term7/kokoro.env, gravada pela tela de extensõ KOKORO_THREADS núcleos usados pra gerar (padrão 4) """ +import json import os import subprocess import sys @@ -105,9 +109,8 @@ def setup(): print("Pronto.") -def speak(out_path, text): +def load_voice(): import onnxruntime as ort - import soundfile as sf from kokoro_onnx import Kokoro cfg = load_settings() @@ -118,24 +121,46 @@ def speak(out_path, text): opts.inter_op_num_threads = 1 session = ort.InferenceSession(os.path.join(root, MODEL_FILES[0]), opts, providers=["CPUExecutionProvider"]) kokoro = Kokoro.from_session(session, os.path.join(root, MODEL_FILES[1])) - samples, rate = kokoro.create(text, voice=cfg["voice"], speed=cfg["speed"], lang=cfg["lang"]) - sf.write(out_path, samples, rate, subtype="PCM_16") + + def speak(out_path, text): + import soundfile as sf + + samples, rate = kokoro.create(text, voice=cfg["voice"], speed=cfg["speed"], lang=cfg["lang"]) + sf.write(out_path, samples, rate, subtype="PCM_16") + + return speak + + +def serve(speak, lines, reply): + """Um pedido por linha; um erro num trecho não derruba os seguintes.""" + for line in lines: + if not line.strip(): + continue + try: + req = json.loads(line) + speak(req["out"], req["text"]) + reply("ok") + except Exception as e: # noqa: BLE001 - qualquer falha vira resposta, não silêncio + reply("erro: " + " ".join(str(e).split())) def main(argv): if argv[1:] == ["--setup"]: return setup() - if len(argv) != 2 or argv[1].startswith("-"): - sys.exit("Uso: term7-kokoro OUT.wav < texto | term7-kokoro --setup") + serving = argv[1:] == ["--serve"] + if not serving and (len(argv) != 2 or argv[1].startswith("-")): + sys.exit("Uso: term7-kokoro --serve | term7-kokoro OUT.wav < texto | term7-kokoro --setup") if not os.path.exists(os.path.join(data_dir(), "ready")): sys.exit("a extensão Kokoro não terminou de instalar (Configurações → Extensões)") # Rodando com o python3 do sistema: passa pro do venv, onde estão as dependências. if os.path.realpath(sys.prefix) != os.path.realpath(os.path.join(data_dir(), "venv")): os.execv(venv_python(), [venv_python(), os.path.abspath(__file__), *argv[1:]]) + if serving: + return serve(load_voice(), sys.stdin, lambda msg: print(msg, flush=True)) text = sys.stdin.read().strip() if not text: sys.exit("texto vazio") - speak(argv[1], text) + load_voice()(argv[1], text) if __name__ == "__main__": diff --git a/extensions/kokoro/test_term7_kokoro.py b/extensions/kokoro/test_term7_kokoro.py index 8a2a659..34824eb 100644 --- a/extensions/kokoro/test_term7_kokoro.py +++ b/extensions/kokoro/test_term7_kokoro.py @@ -17,6 +17,23 @@ loader.exec_module(ext) +class Servidor(unittest.TestCase): + def test_um_pedido_por_linha_e_erro_nao_derruba(self): + made, replies = [], [] + + def speak(out, text): + if text == "quebra": + raise ValueError("voz\ninexistente") + made.append((out, text)) + + lines = ['{"text": "Olá.", "out": "/t/0.wav"}\n', "\n", "não é json\n", '{"text": "quebra", "out": "/t/1.wav"}\n', '{"text": "Fim.", "out": "/t/2.wav"}\n'] + ext.serve(speak, lines, replies.append) + self.assertEqual(made, [("/t/0.wav", "Olá."), ("/t/2.wav", "Fim.")]) + self.assertEqual(replies[0], "ok") + self.assertTrue(replies[1].startswith("erro: ")) + self.assertEqual(replies[2:], ["erro: voz inexistente", "ok"]) + + class Configuracao(unittest.TestCase): def test_le_o_arquivo_que_o_term7_grava(self): # Formato do render_env do extensions.rs. diff --git a/src-tauri/src/speech.rs b/src-tauri/src/speech.rs index 2ca73f6..7338aca 100644 --- a/src-tauri/src/speech.rs +++ b/src-tauri/src/speech.rs @@ -1,18 +1,18 @@ //! Saída de voz: lê em voz alta a última resposta do Claude da aba (ou um texto //! de teste) com a API `/audio/speech` no formato da OpenAI (Groq, OpenAI...) ou //! com uma extensão de voz local (tipo `tts`, como a do Kokoro). -//! O áudio vem em trechos curtos: o próximo é gerado enquanto o atual toca. +//! O áudio vem em trechos: os seguintes são gerados enquanto o atual toca. use std::{ - io::Write, + io::{BufRead, BufReader, Write}, os::unix::fs::OpenOptionsExt, path::PathBuf, - process::{Command, Stdio}, + process::{Child, ChildStdin, ChildStdout, Command, Stdio}, sync::{ atomic::{AtomicU64, Ordering}, - Arc, Mutex, + mpsc, Mutex, }, - thread::{self, JoinHandle}, + thread, time::Duration, }; @@ -29,9 +29,12 @@ const CHUNK_CHARS: usize = 200; /// Nada toca até o primeiro trecho chegar inteiro: curto, a fala começa logo e /// os seguintes são gerados enquanto ele toca. const FIRST_CHUNK_CHARS: usize = 80; +/// Voz local: os trechos crescem aos poucos. Um gerado enquanto o anterior toca +/// precisa ficar pronto antes de ele acabar; crescendo 25% por trecho, isso vale +/// mesmo com a geração quase em tempo real (1 núcleo). +const LOCAL_CHUNK_CHARS: &[usize] = &[80, 100, 125, 156, 195, 244, 305, 381, 476, 600]; /// Pela API, resposta longa vira custo e cota (o Groq gratuito dá 100 pedidos por -/// dia e 1.200 tokens por minuto): lê só o começo. A voz local lê tudo: só gera um -/// trecho à frente, então parar no meio não desperdiça nada. +/// dia e 1.200 tokens por minuto): lê só o começo. A voz local lê tudo. const API_MAX_CHARS: usize = 600; /// Tentativas por trecho quando a API pede pra esperar (429) ou falha do lado dela (5xx). const ATTEMPTS: usize = 3; @@ -44,6 +47,8 @@ pub struct SpeechState { generation: AtomicU64, /// pid do pw-play/aplay tocando agora. player: Mutex>, + /// pid da voz local gerando os trechos da leitura atual. + generator: Mutex>, } /// "- item", "* item", "1. item", "2) item" -> "item". @@ -134,29 +139,11 @@ pub(crate) fn speakable(markdown: &str) -> String { sentences.join(" ") } -/// Quebra uma frase em pedaços de até `max` caracteres, entre palavras. -fn fit(sentence: &str, max: usize) -> Vec { - let mut out = Vec::new(); - let mut cur = String::new(); - for word in sentence.split_whitespace() { - let word: String = word.chars().take(max).collect(); - if !cur.is_empty() && cur.chars().count() + 1 + word.chars().count() > max { - out.push(std::mem::take(&mut cur)); - } - if !cur.is_empty() { - cur.push(' '); - } - cur.push_str(&word); - } - if !cur.is_empty() { - out.push(cur); - } - out -} - -/// Trechos de até `max` caracteres (o primeiro, até `first`), juntando frases -/// inteiras; para no fim da frase que passaria de `limit` no total. -pub(crate) fn chunks(text: &str, first: usize, max: usize, limit: usize) -> Vec { +/// Trechos que juntam frases inteiras; o trecho `i` tem até `caps[i]` caracteres +/// (o último valor vale pros seguintes). Frase que não cabe é cortada entre +/// palavras. Para no fim da frase que passaria de `limit` no total. +pub(crate) fn chunks(text: &str, caps: &[usize], limit: usize) -> Vec { + let cap = |i: usize| caps[i.min(caps.len() - 1)]; let mut sentences: Vec = Vec::new(); let mut cur = String::new(); for word in text.split_whitespace() { @@ -180,24 +167,28 @@ pub(crate) fn chunks(text: &str, first: usize, max: usize, limit: usize) -> Vec< break; } total += len; - for piece in fit(&sentence, max) { - let n = piece.chars().count(); - let cap = if out.len() == 1 { first } else { max }; - match out.last_mut() { - Some(last) if last.chars().count() + 1 + n <= cap => { - last.push(' '); - last.push_str(&piece); - } - _ => out.push(piece), + let room = |out: &Vec| out.last().map_or(0, |last| cap(out.len() - 1).saturating_sub(last.chars().count() + 1)); + if len <= room(&out) { + let last = out.last_mut().unwrap(); + last.push(' '); + last.push_str(&sentence); + continue; + } + // Não cabe no trecho atual: começa outro, cortando entre palavras se precisar. + out.push(String::new()); + for word in sentence.split_whitespace() { + let word: String = word.chars().take(cap(out.len() - 1)).collect(); + let last = out.last().unwrap(); + if !last.is_empty() && word.chars().count() > room(&out) { + out.push(String::new()); + } + let last = out.last_mut().unwrap(); + if !last.is_empty() { + last.push(' '); } + last.push_str(&word); } } - // Uma frase só já passou do primeiro trecho: corta entre palavras. - if out.first().is_some_and(|head| head.chars().count() > first) { - let pieces = fit(&out[0], first); - out[0] = pieces[0].clone(); - out.insert(1, pieces[1..].join(" ")); - } out } @@ -239,22 +230,53 @@ fn engine(s: &settings::Settings) -> Result { } } -fn synthesize_local(python: &PathBuf, script: &PathBuf, text: &str, out: &PathBuf) -> Result<(), String> { - let mut child = Command::new(python) - .arg(script) - .arg(out) - .stdin(Stdio::piped()) - .stdout(Stdio::null()) - .stderr(Stdio::piped()) - .spawn() - .map_err(|e| format!("não deu pra rodar a voz local: {e}"))?; - child.stdin.take().unwrap().write_all(text.as_bytes()).map_err(|e| e.to_string())?; - let res = child.wait_with_output().map_err(|e| e.to_string())?; - if !res.status.success() { - let _ = std::fs::remove_file(out); - return Err(format!("a voz local falhou: {}", voice::last_line(&res.stderr))); +/// Voz local aberta durante uma leitura: carrega o modelo uma vez e gera os +/// trechos em sequência (`--serve`: uma linha JSON por trecho, responde "ok"). +struct LocalVoice { + child: Child, + stdin: ChildStdin, + stdout: BufReader, +} + +impl LocalVoice { + fn start(state: &SpeechState, python: &PathBuf, script: &PathBuf) -> Result { + let mut child = Command::new(python) + .arg(script) + .arg("--serve") + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::null()) + .spawn() + .map_err(|e| format!("não deu pra rodar a voz local: {e}"))?; + *state.generator.lock().unwrap() = Some(child.id()); + let stdin = child.stdin.take().unwrap(); + let stdout = BufReader::new(child.stdout.take().unwrap()); + Ok(Self { child, stdin, stdout }) + } + + fn synthesize(&mut self, text: &str, out: &PathBuf) -> Result<(), String> { + let request = serde_json::json!({ "text": text, "out": out }).to_string(); + writeln!(self.stdin, "{request}").and_then(|_| self.stdin.flush()).map_err(|_| "a voz local parou".to_string())?; + let mut line = String::new(); + self.stdout.read_line(&mut line).map_err(|e| e.to_string())?; + match line.trim() { + "ok" => Ok(()), + "" => Err("a voz local parou (a extensão está atualizada?)".into()), + err => { + let _ = std::fs::remove_file(out); + Err(format!("a voz local falhou: {}", err.trim_start_matches("erro: "))) + } + } + } + + fn close(mut self, state: &SpeechState) { + let _ = self.child.kill(); + let _ = self.child.wait(); + let mut generator = state.generator.lock().unwrap(); + if *generator == Some(self.child.id()) { + *generator = None; + } } - Ok(()) } fn tmp_path(name: &str) -> PathBuf { @@ -389,17 +411,41 @@ fn play(state: &SpeechState, wav: &PathBuf) -> Result<(), String> { fn stop_playing(state: &SpeechState) { state.generation.fetch_add(1, Ordering::SeqCst); - if let Some(pid) = *state.player.lock().unwrap() { + // A voz local também: parada no meio de um trecho, solta a CPU na hora. + for pid in [*state.player.lock().unwrap(), *state.generator.lock().unwrap()].into_iter().flatten() { let _ = Command::new("kill").arg(pid.to_string()).status(); } } -type Job = JoinHandle>; - -/// Trecho já pedido que não vai mais tocar: espera e apaga o arquivo. -fn discard(job: Option) { - if let Some(Ok(Ok(path))) = job.map(JoinHandle::join) { - let _ = std::fs::remove_file(path); +/// Gera os trechos em ordem, sem esperar o tocador: vai adiantando enquanto ele +/// toca. Para quando a fala é interrompida ou o tocador desiste (canal fechado). +fn produce(app: &AppHandle, generation: u64, engine: Engine, parts: Vec, tx: mpsc::Sender>) { + let state = app.state::(); + let current = || state.generation.load(Ordering::SeqCst) == generation; + let mut local: Option = None; + for (i, text) in parts.iter().enumerate() { + if !current() { + break; + } + let path = tmp_path(&format!("{generation}-{i}.wav")); + let result = match &engine { + Engine::Api(cfg) => synthesize_retrying(app, generation, cfg, text, &path), + Engine::Local { python, script } => match &mut local { + Some(voice) => voice.synthesize(text, &path), + None => LocalVoice::start(&state, python, script).and_then(|voice| local.insert(voice).synthesize(text, &path)), + }, + }; + let failed = result.is_err(); + if tx.send(result.map(|_| path.clone())).is_err() { + let _ = std::fs::remove_file(&path); + break; + } + if failed { + break; + } + } + if let Some(voice) = local { + voice.close(&state); } } @@ -411,47 +457,28 @@ fn speak(app: &AppHandle, text: &str) -> Result<(), String> { let generation = state.generation.load(Ordering::SeqCst); let current = || state.generation.load(Ordering::SeqCst) == generation; - let engine = Arc::new(engine(&settings::load(app))?); - let limit = match &*engine { - Engine::Api(_) => API_MAX_CHARS, - Engine::Local { .. } => usize::MAX, - }; - let parts = chunks(text, FIRST_CHUNK_CHARS, CHUNK_CHARS, limit); - let request = |i: usize| -> Job { - let (app, engine, text, path) = (app.clone(), engine.clone(), parts[i].clone(), tmp_path(&format!("{generation}-{i}.wav"))); - thread::spawn(move || { - match &*engine { - Engine::Api(cfg) => synthesize_retrying(&app, generation, cfg, &text, &path), - Engine::Local { python, script } => synthesize_local(python, script, &text, &path), - } - .map(|_| path) - }) + let engine = engine(&settings::load(app))?; + let parts = match engine { + Engine::Api(_) => chunks(text, &[FIRST_CHUNK_CHARS, CHUNK_CHARS], API_MAX_CHARS), + Engine::Local { .. } => chunks(text, LOCAL_CHUNK_CHARS, usize::MAX), }; + let (tx, rx) = mpsc::channel(); + let app2 = app.clone(); + thread::spawn(move || produce(&app2, generation, engine, parts, tx)); - let mut next = (!parts.is_empty()).then(|| request(0)); - let mut i = 0; - while let Some(job) = next.take() { - let wav = match job.join() { - Ok(Ok(wav)) => wav, - // Interrompida no meio: não é erro pra mostrar. - _ if !current() => break, - Ok(Err(e)) => return Err(e), - Err(_) => return Err("falhou ao gerar o áudio".into()), - }; - i += 1; + for item in rx { + // Interrompida no meio: não é erro pra mostrar. Sair fecha o canal e o + // gerador apaga o que ainda produzir. if !current() { - let _ = std::fs::remove_file(&wav); + if let Ok(wav) = item { + let _ = std::fs::remove_file(wav); + } break; } - if i < parts.len() { - next = Some(request(i)); - } + let wav = item?; let played = play(&state, &wav); let _ = std::fs::remove_file(&wav); - if played.is_err() || !current() { - discard(next.take()); - played?; - } + played?; } Ok(()) } @@ -577,22 +604,25 @@ mod tests { #[test] fn divide_em_trechos_por_frase() { let text = "Primeira frase. Segunda frase! Terceira?"; - assert_eq!(chunks(text, 20, 20, 1000), ["Primeira frase.", "Segunda frase!", "Terceira?"]); - assert_eq!(chunks(text, 35, 35, 1000), ["Primeira frase. Segunda frase!", "Terceira?"]); + assert_eq!(chunks(text, &[20], 1000), ["Primeira frase.", "Segunda frase!", "Terceira?"]); + assert_eq!(chunks(text, &[35], 1000), ["Primeira frase. Segunda frase!", "Terceira?"]); // Frase maior que o trecho quebra entre palavras. - assert_eq!(chunks("um dois três quatro", 9, 9, 1000), ["um dois", "três", "quatro"]); + assert_eq!(chunks("um dois três quatro", &[9], 1000), ["um dois", "três", "quatro"]); // Passou do limite: para no fim da frase anterior. - assert_eq!(chunks(text, 200, 200, 32), ["Primeira frase. Segunda frase!"]); - assert!(chunks(" ", 80, 200, 1000).is_empty()); + assert_eq!(chunks(text, &[200], 32), ["Primeira frase. Segunda frase!"]); + assert!(chunks(" ", &[80, 200], 1000).is_empty()); } #[test] fn primeiro_trecho_e_curto() { // Frases curtas: o primeiro trecho junta só o que cabe nele. let text = "Primeira frase. Segunda frase! Terceira?"; - assert_eq!(chunks(text, 16, 200, 1000), ["Primeira frase.", "Segunda frase! Terceira?"]); + assert_eq!(chunks(text, &[16, 200], 1000), ["Primeira frase.", "Segunda frase! Terceira?"]); // Primeira frase longa: corta entre palavras e o resto vira o segundo trecho. - assert_eq!(chunks("um dois três quatro. Fim.", 8, 200, 1000), ["um dois", "três quatro.", "Fim."]); + assert_eq!(chunks("um dois três quatro. Fim.", &[8, 200], 1000), ["um dois", "três quatro. Fim."]); + // Voz local: trechos crescem aos poucos (cada um fica pronto antes do anterior acabar de tocar). + let text = "Um dois três. Quatro cinco seis. Sete oito nove. Dez onze doze. Treze."; + assert_eq!(chunks(text, &[14, 18, 34], 1000), ["Um dois três.", "Quatro cinco seis.", "Sete oito nove. Dez onze doze.", "Treze."]); } #[test] diff --git a/src/lib/voice.test.ts b/src/lib/voice.test.ts index 6b98e8b..f521e31 100644 --- a/src/lib/voice.test.ts +++ b/src/lib/voice.test.ts @@ -4,7 +4,7 @@ import { voiceCommand } from "./voice"; describe("frase de enviar do ditado", () => { it("aceita os jeitos que o Whisper escreve term7", () => { // Variações tiradas de ditados reais. - for (const end of ["term7 pronto", "Term 7, pronto.", "Terme 7 pronto!", "Term set pronto", "term sete, pronto", "Termsete pronto.", "TERM7 PRONTO", "Termo 7, pronto.", "Termo sete pronto", "Term-7 pronto.", "Terms set pronto", "Term Seth, pronto."]) { + for (const end of ["term7 pronto", "Term 7, pronto.", "Terme 7 pronto!", "Term set pronto", "term sete, pronto", "Termsete pronto.", "TERM7 PRONTO", "Termo 7, pronto.", "Termo sete pronto", "Term-7 pronto.", "Terms set pronto", "Term Seth, pronto.", "Temos set pronto", "Tens 7 pronto", "Ter 7 pronto", "Thermo 7 pronto", "Term's 7 pronto", "Ternset pronto", "Term 7pronto", "Term7 pronta"]) { expect(voiceCommand(`Roda os testes do login. ${end}`)).toEqual({ text: "Roda os testes do login", send: true }); } }); @@ -16,6 +16,10 @@ describe("frase de enviar do ditado", () => { it("frase no meio ou incompleta não manda", () => { expect(voiceCommand("o term7 pronto pra release, roda o build")).toEqual({ text: "o term7 pronto pra release, roda o build", send: false }); expect(voiceCommand("ficou pronto")).toEqual({ text: "ficou pronto", send: false }); + // Palavra parecida sem o número não é a frase. + expect(voiceCommand("chegou o tempo, pronto")).toEqual({ text: "chegou o tempo, pronto", send: false }); + expect(voiceCommand("faz o teste 8 pronto")).toEqual({ text: "faz o teste 8 pronto", send: false }); + expect(voiceCommand("dos 10 testes, tem 7 prontos")).toEqual({ text: "dos 10 testes, tem 7 prontos", send: false }); expect(voiceCommand("")).toEqual({ text: "", send: false }); }); diff --git a/src/lib/voice.ts b/src/lib/voice.ts index 07e0fe7..0939aa4 100644 --- a/src/lib/voice.ts +++ b/src/lib/voice.ts @@ -1,23 +1,29 @@ /** Frase padrão que, no fim do ditado, manda com Enter. */ export const DEFAULT_SEND_PHRASE = "term7 pronto"; -// O Whisper escreve "term7" de vários jeitos: "Term 7", "Terme 7", "Termo 7", "Term-7", "Term set", "Terms set", "termsete"... -const TERM7_HEAD = /^ter?m[aeo]?s?$/; +// O Whisper escreve "term7" de vários jeitos: "Term 7", "Termo 7", "Temos set", "Tens 7", +// "Thermo sete", "Ternset"... Aceita "te" + r/n/m + vogal/s seguido do número; o +// número junto é que evita confundir com uma palavra qualquer. +const TERM7_HEAD = /^th?e[rn]?[mn]?[aeo]?s?$/; const TERM7_NUMBER = /^(7|sete|set|seth|seven)$/; -const TERM7_JOINED = /^ter?m[aeo]?s?-?(7|sete|set|seth|seven)$/; +const TERM7_JOINED = /^th?e[rn]?[mn]?[aeo]?s?(sete|set|seth|seven)$/; +// "pronta": o Whisper erra a terminação. Plural não: "tem 7 prontos" é frase normal. +const PRONTO = /^pront[oa]$/; -/** Palavra comparável: minúscula, sem acento e sem pontuação em volta. */ +/** Palavra comparável: minúscula, sem acento, sem apóstrofo e sem pontuação em volta. */ function normalize(word: string) { return word .normalize("NFD") .replace(/\p{M}/gu, "") .toLowerCase() + .replace(/['’]/g, "") .replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, ""); } -/** Palavras do texto já com as variações de "term7" juntadas, e onde cada uma começa no original. */ +/** Palavras do texto já com as variações de "term7" juntadas, e onde cada uma começa no original. + * Número e letras grudados viram palavras separadas ("term7" → "term" "7", "7pronto" → "7" "pronto"). */ function words(text: string) { - const raw = [...text.matchAll(/\S+/g)].map((m) => ({ word: normalize(m[0]), start: m.index! })).filter((w) => w.word); + const raw = [...text.matchAll(/\p{N}+|[^\s\p{N}]+/gu)].map((m) => ({ word: normalize(m[0]), start: m.index! })).filter((w) => w.word); const out: { word: string; start: number }[] = []; for (let i = 0; i < raw.length; i++) { const { word, start } = raw[i]; @@ -25,7 +31,7 @@ function words(text: string) { else if (TERM7_HEAD.test(word) && TERM7_NUMBER.test(raw[i + 1]?.word ?? "")) { out.push({ word: "term7", start }); i++; - } else out.push({ word, start }); + } else out.push({ word: PRONTO.test(word) ? "pronto" : word, start }); } return out; }