primocode 10.14.1 → 10.15.0

package/voz/primo_voz/__main__.py

@@ -31,6 +31,7 @@ from __future__ import annotations
 import json
 import os
 import queue
+import shutil
 import subprocess
 import sys
 import tempfile
@@ -41,7 +42,10 @@ from pathlib import Path
 AQUI = Path(__file__).resolve().parent
 sys.path.insert(0, str(AQUI.parent))
 
-from primo_voz import escuta, transcrever  # noqa: E402
+from primo_voz import conversa, escuta, identidade, painel, transcrever  # noqa: E402
+from primo_voz import tela as dados_tela  # noqa: E402
+from primo_voz.luz import Luz  # noqa: E402
+from primo_voz.sons import Sons  # noqa: E402
 
 
 class Bolinha:
@@ -57,13 +61,49 @@ class Bolinha:
         self.quando = 0.0
         if os.environ.get("PRIMOCODE_SEM_ORB") == "1":
             return
+        self.ao_acao = None
+        # No Mac com PyObjC o rosto é o HUD (hud.py); senão, a orbe de antes.
+        modulo = "primo_voz.orbe"
+        if sys.platform == "darwin" and os.environ.get("PRIMOCODE_HUD") != "0":
+            try:
+                import AppKit  # noqa: F401
+                modulo = "primo_voz.hud"
+            except ImportError:
+                pass
+        self.modulo = modulo
         try:
-            self.p = subprocess.Popen([sys.executable, "-m", "primo_voz.orbe"], cwd=str(AQUI.parent),
-                                      stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            self.p = subprocess.Popen([sys.executable, "-m", modulo], cwd=str(AQUI.parent),
+                                      stdin=subprocess.PIPE,
+                                      stdout=subprocess.PIPE if modulo.endswith("hud") else subprocess.DEVNULL,
+                                      stderr=subprocess.DEVNULL,
                                       env={**os.environ, "PYTHONPATH": str(AQUI.parent)}, text=True)
+            if modulo.endswith("hud"):
+                threading.Thread(target=self._ler_acoes, daemon=True).start()
         except Exception:
             self.p = None
 
+    def _ler_acoes(self) -> None:
+        """O HUD manda {"acao":"ptt"} quando a pessoa clica nos anéis."""
+        try:
+            for linha in self.p.stdout:
+                try:
+                    a = json.loads(linha).get("acao")
+                except ValueError:
+                    continue
+                if a and self.ao_acao:
+                    self.ao_acao(a)
+        except Exception:
+            pass
+
+    def enviar(self, obj: dict) -> None:
+        if not self.p or self.p.poll() is not None or not self.modulo.endswith("hud"):
+            return
+        try:
+            self.p.stdin.write(json.dumps(obj, ensure_ascii=False) + "\n")
+            self.p.stdin.flush()
+        except Exception:
+            pass
+
     def estado(self, estado: str, nivel: float = None) -> None:
         if not self.p or self.p.poll() is not None:
             return
@@ -71,6 +111,8 @@ class Bolinha:
         if estado == self.ultimo and (nivel is None or agora - self.quando < 1 / 15):
             return
         self.ultimo, self.quando = estado, agora
+        if not self.modulo.endswith("hud"):
+            estado = {"executando": "pensando", "interrompido": "ouvindo", "dormindo": "esperando"}.get(estado, estado)
         msg = {"estado": estado}
         if nivel is not None:
             msg["nivel"] = round(min(1.0, nivel), 3)
@@ -131,25 +173,60 @@ PS_TOCAR_MP3 = (
 
 
 class Voz:
-    """Microfone → transcrição → terminal. Terminal → voz."""
+    """Microfone → transcrição → terminal. Terminal → voz. O Primo.
+
+    A conversa (estados, frases, resumo, comandos) é conversa.py, puro e testado;
+    o painel é hud.py; luz.py e sons.py são o resto do corpo."""
 
     def __init__(self, servidor: str, token: str, voz_escolhida: str = "antonio"):
         self.servidor = servidor
         self.token = token
         self.voz = voz_escolhida
-        # O Whisper local carrega em segundo plano desde já: senão a primeira
-        # frase esperaria o modelo inteiro subir.
+        self.cfg = identidade.ler()
+        self.nome = self.cfg["nome"]
+        # nome = só responde se começar pelo nome · sempre = sem palavra · tecla = só ao clicar no painel
+        self.modo = os.environ.get("PRIMOCODE_ATIVACAO", "nome")
         self.local = transcrever.disponivel()
         if self.local:
             transcrever.aquecer()
         self.gravador = escuta.Gravador()
+        self.gravador.vad = escuta.criar_vad()
         self.corte = escuta.Corte()
         self.bolinha = Bolinha()
+        self.bolinha.ao_acao = self._acao_do_painel
+        self.luz = Luz(bool(self.cfg.get("luz", True)))
+        self.sons = Sons(bool(self.cfg.get("sons", True)))
+        self.maquina = conversa.Maquina("ouvindo")
         self._blocos: "queue.Queue" = queue.Queue()
-        self._falas: "queue.Queue" = queue.Queue()
+        self._falas: "queue.Queue" = queue.Queue()      # frases de texto
+        self._audios: "queue.Queue" = queue.Queue(maxsize=2)   # mp3 já pronto
         self._vivo = True
         self._falando = False
         self._parar_fala = threading.Event()
+        self._acordado_ate = 0.0       # janela de conversa: sem repetir o nome
+        self._ptt_ate = 0.0
+        self._ultima_conf = 0.0
+        self._ultimo_ok = ""
+        self.bolinha.enviar({"nome": self.nome})
+
+    # ── o corpo: painel, luz e som reagem ao mesmo estado ───────────────
+
+    def _estado(self, estado: str, nivel: float = None) -> None:
+        mudou = estado != self.bolinha.ultimo
+        self.bolinha.estado(estado, nivel)
+        self.luz.mudar(estado, nivel)
+        if mudou and estado in ("ouvindo", "pensando"):
+            self.sons.tocar(estado, falando=self._falando)
+
+    def _acao_do_painel(self, acao: str) -> None:
+        if acao == "ptt":                      # clique nos anéis = falar agora
+            self._ptt_ate = time.time() + 10
+            self.sons.tocar("acordou", falando=self._falando)
+
+    def _erro(self, texto: str) -> None:
+        self.luz.erro()
+        self.sons.tocar("erro")
+        self.bolinha.enviar({"resposta": texto})
 
     # ── o ouvido ─────────────────────────────────────────────────────────
 
@@ -157,16 +234,33 @@ class Voz:
         if not self._vivo:
             return
         nivel = escuta.rms(bloco)
-        # Enquanto ele fala, o microfone só serve para uma coisa: saber se a
-        # pessoa falou POR CIMA. O que entra aqui é a voz dele saindo da
-        # caixa de som, e não pode virar pedido.
+        if not self._falando and self.bolinha.ultimo:      # o volume REAL do mic vai para as barras da tela
+            self.bolinha.estado(self.bolinha.ultimo, dados_tela.nivel_do_mic(nivel))
+        # Enquanto ele fala, o microfone só serve para saber se a pessoa falou
+        # POR CIMA (interrupção). A voz dele na caixa de som não vira pedido.
         if self._falando:
             self.corte.ele_falou(nivel)
-            if self.corte.alguem_cortou(nivel):
-                self._parar_fala.set()
+            if self.maquina.pode_cortar and self.corte.alguem_cortou(nivel):
+                self._interromper()
             return
         self._blocos.put(bloco)
 
+    def _interromper(self) -> None:
+        self.maquina.mandar("cortou")
+        self._parar_fala.set()
+        self._limpar_falas()
+        self._acordado_ate = time.time() + 20   # falou por cima: já está conversando
+        self.maquina.mandar("escutar")
+        self._estado("ouvindo")
+
+    def _limpar_falas(self) -> None:
+        for fila in (self._falas, self._audios):
+            while True:
+                try:
+                    fila.get_nowait()
+                except queue.Empty:
+                    break
+
     def _esvaziar_blocos(self) -> None:
         while True:
             try:
@@ -174,6 +268,34 @@ class Voz:
             except queue.Empty:
                 return
 
+    def _parcial(self) -> None:
+        """Transcrição ao vivo: a cada ~1,6 s de fala, uma passada no que já foi dito."""
+        if not self.local or getattr(self, "_parcial_rodando", False):
+            return
+        copia = list(self.gravador._blocos)
+        if not copia:
+            return
+        self._parcial_rodando = True
+
+        def trabalho():
+            try:
+                import numpy as np
+                import wave as _w
+                arq = Path(tempfile.gettempdir()) / "primo-voz-parcial.wav"
+                with _w.open(str(arq), "wb") as w:
+                    w.setnchannels(1)
+                    w.setsampwidth(2)
+                    w.setframerate(escuta.TAXA)
+                    w.writeframes(np.concatenate(copia).astype(np.int16).tobytes())
+                t = transcrever.limpar(transcrever.transcrever(arq))
+                if t and self.gravador._falando:
+                    self.bolinha.enviar({"transcricao": t, "parcial": True})
+            except Exception:
+                pass
+            finally:
+                self._parcial_rodando = False
+        threading.Thread(target=trabalho, daemon=True).start()
+
     def _ouvir(self) -> None:
         mic = escuta.Microfone(self._ao_receber)
         try:
@@ -183,20 +305,26 @@ class Voz:
             self.parar()
             return
         falar_para_o_node({"tipo": "pronto"})
-        self.bolinha.estado("esperando")
+        self._estado("ouvindo" if self.modo == "sempre" else "dormindo")
+        self.sons.tocar("acordou")
+        self._saudar()
         while self._vivo:
             self.gravador.comecar()
             acabou = False
+            ultimo_parcial = 0.0
             while self._vivo and not acabou:
                 try:
                     bloco = self._blocos.get(timeout=0.3)
                 except queue.Empty:
                     continue
                 acabou = self.gravador.alimentar(bloco)
-                # A bolinha acende com a voz da pessoa, no tamanho da voz.
                 if self.gravador._falando and not self._falando:
                     lim = max(1e-6, self.gravador._limiar())
+                    self.luz.mudar("ouvindo", min(1.0, escuta.rms(bloco) / lim * 0.35))
                     self.bolinha.estado("ouvindo", min(1.0, escuta.rms(bloco) / lim * 0.35))
+                    if time.time() - ultimo_parcial > 1.6 and self.gravador.segundos > 1.0:
+                        ultimo_parcial = time.time()
+                        self._parcial()
             if not self._vivo:
                 break
             if self.gravador.encerrou_por == "ninguem-falou" or self.gravador.segundos < 0.4:
@@ -204,16 +332,75 @@ class Voz:
             wav = self.gravador.gravar_wav(Path(tempfile.gettempdir()) / "primo-voz-fala.wav")
             if not wav:
                 continue
-            self.bolinha.estado("pensando")
             texto = transcrever.limpar(self._transcrever(wav))
-            if texto:
-                # Pensando até o terminal dizer o contrário (a resposta em
-                # voz, ou {"tipo":"estado"} quando ele termina sem falar).
-                falar_para_o_node({"tipo": "ouvi", "texto": texto})
-            else:
-                self.bolinha.estado("esperando")
+            self._tratar(texto)
         mic.fechar()
 
+    def _tratar(self, texto: str) -> None:
+        """O que foi dito: ativação, apresentação, comando local ou pedido ao terminal."""
+        if not texto:
+            self._estado(self.maquina.estado if self.maquina.estado != "pensando" else "ouvindo")
+            return
+        agora = time.time()
+        acordado = (self.modo == "sempre" or agora < self._acordado_ate or agora < self._ptt_ate)
+        chamou, resto = conversa.ativacao(texto, self.nome)
+        if not acordado and not chamou:
+            self._estado("dormindo")          # não era comigo: não vira pedido
+            return
+        texto = resto if chamou else texto
+        self._acordado_ate = agora + 25
+        self.bolinha.enviar({"transcricao": texto or f"({self.nome}?)", "parcial": False})
+        if not texto:                          # só chamou pelo nome
+            self.sons.tocar("entendeu")
+            self._dizer(identidade.variar(["Oi! Fala.", "Pois não?", "Tô aqui."], self._ultimo_ok))
+            self.maquina.mandar("ativar")
+            return
+        novo = identidade.aprender(texto)
+        if novo:
+            self.cfg = identidade.salvar(**novo)
+            if "nome" in novo:
+                self.nome = novo["nome"]
+                self.bolinha.enviar({"nome": self.nome})
+                self._dizer(f"Fechado. Agora eu me chamo {self.nome}.")
+            else:
+                self._dizer(f"Prazer, {novo['pessoa']}! Vou lembrar.")
+            return
+        cmd = conversa.comando(texto)
+        if cmd == "esconder":
+            self.bolinha.enviar({"painel": "esconder"})
+            self.sons.tocar("painel_fecha")
+            return
+        if cmd == "mostrar":
+            self.bolinha.enviar({"painel": "mostrar"})
+            self.sons.tocar("painel_abre")
+            return
+        if cmd == "parar":
+            self._parar_fala.set()
+            self._limpar_falas()
+            self.maquina.mandar("parar")
+            falar_para_o_node({"tipo": "parar"})
+            self._estado("ouvindo")
+            return
+        if cmd == "olhar":
+            texto = "Tire um print da minha tela agora, olhe e me diga em uma ou duas frases o que está acontecendo."
+        elif cmd == "resumo_dia":
+            texto = ("Faça o resumo do meu dia no projeto atual, em poucas frases faladas: PRs abertos (gh pr list), "
+                     "se os testes passam e o que mudou hoje no git. O detalhe vai no painel.")
+        self.sons.tocar("entendeu", falando=self._falando)
+        self.maquina.mandar("ouviu")
+        self._estado("pensando")
+        falar_para_o_node({"tipo": "ouvi", "texto": texto})
+
+    def _saudar(self) -> None:
+        if self.cfg.get("pessoa") or True:
+            self._dizer(identidade.saudacao(time.localtime().tm_hour, self.cfg.get("pessoa", ""), self.nome))
+
+    def _dizer(self, texto: str) -> None:
+        """Fala uma frase curta já pronta (sem passar pelo resumo)."""
+        self._ultimo_ok = texto
+        self.bolinha.enviar({"resposta": texto})
+        self._falas.put(texto)
+
     def _transcrever(self, wav: Path) -> str:
         """Primeiro aqui, com o Whisper local. O servidor só entra se o local
         não estiver instalado ou falhar — e diz que caiu."""
@@ -242,45 +429,83 @@ class Voz:
             avisar(f"não deu para transcrever: {e}")
             return ""
 
-    # ── a boca ───────────────────────────────────────────────────────────
+    # ── a boca: frase a frase, a próxima já sendo gerada enquanto a atual toca ──
 
     def _falar_em_fila(self) -> None:
+        """Sintetiza a próxima frase enquanto a anterior toca (o 1º áudio sai
+        depois de UMA frase, não do texto inteiro)."""
+        threading.Thread(target=self._tocar_em_fila, daemon=True).start()
         while self._vivo:
             try:
                 texto = self._falas.get(timeout=0.3)
             except queue.Empty:
                 continue
-            self._falar(texto)
-
-    def _falar(self, texto: str) -> None:
-        limpo = " ".join(str(texto).split())
+            for frase in conversa.dividir_frases(texto):
+                mp3 = self._sintetizar(frase)
+                if mp3:
+                    while self._vivo:
+                        try:
+                            self._audios.put(mp3, timeout=0.3)
+                            break
+                        except queue.Full:
+                            continue
+
+    def _sintetizar(self, frase: str) -> "Path | None":
+        limpo = " ".join(str(frase).split())[:600]
         if not limpo:
-            return
-        if len(limpo) > 900:
-            limpo = limpo[:880].rsplit(" ", 1)[0] + "…"
+            return None
         mp3 = Path(tempfile.gettempdir()) / f"primo-voz-{int(time.time() * 1000)}.mp3"
         narrar = AQUI.parent.parent / "studio" / "narrar.py"
-        r = subprocess.run(
-            [sys.executable, str(narrar), "falar", "--texto", limpo, "--saida", str(mp3), "--voz", self.voz],
-            capture_output=True, timeout=180)
+        try:
+            r = subprocess.run(
+                [sys.executable, str(narrar), "falar", "--texto", limpo, "--saida", str(mp3), "--voz", self.voz],
+                capture_output=True, timeout=180)
+        except Exception as e:
+            avisar(f"não deu para gerar a voz: {e}")
+            return None
         if r.returncode != 0 or not mp3.exists():
+            if sys.platform == "darwin" and shutil.which("say"):   # reserva: a voz do sistema
+                aiff = mp3.with_suffix(".aiff")
+                if subprocess.run(["say", "-o", str(aiff), limpo], capture_output=True).returncode == 0:
+                    return aiff
             avisar(motivo_da_narracao(r))
-            return
-        self._falando = True
-        self._parar_fala.clear()
-        self.bolinha.estado("falando", 0.6)
-        try:
-            self._tocar(mp3)
-        finally:
-            self._falando = False
-            self.bolinha.estado("esperando")
-            self.corte.nivel_dele = 0.0
-            # O que o microfone pegou enquanto ele falava é a voz dele.
-            self._esvaziar_blocos()
+            self._erro("Não consegui gerar a voz. O texto está no painel.")
+            return None
+        return mp3
+
+    def _tocar_em_fila(self) -> None:
+        while self._vivo:
             try:
-                mp3.unlink()
-            except OSError:
-                pass
+                arq = self._audios.get(timeout=0.3)
+            except queue.Empty:
+                if self._falando and self._falas.empty():
+                    self._acabou_de_falar()
+                continue
+            if not self._falando:
+                self._falando = True
+                self._parar_fala.clear()
+                self.maquina.mandar("resposta")
+                self._estado("falando", 0.6)
+            try:
+                self._tocar(arq)
+            finally:
+                try:
+                    arq.unlink()
+                except OSError:
+                    pass
+                if self._parar_fala.is_set():
+                    self._acabou_de_falar()
+
+    def _acabou_de_falar(self) -> None:
+        if not self._falando:
+            return
+        self._falando = False
+        self.maquina.mandar("fim_fala")
+        self._estado("ouvindo" if self.modo == "sempre" or time.time() < self._acordado_ate else "dormindo")
+        self._acordado_ate = max(self._acordado_ate, time.time() + 20)
+        self.sons.tocar("pronto")
+        self.corte.nivel_dele = 0.0
+        self._esvaziar_blocos()      # o que o microfone pegou era a voz dele
 
     def _tocar(self, arquivo: Path) -> None:
         """Toca o mp3 com o que a máquina tiver — interrompível, porque falar
@@ -296,12 +521,19 @@ class Voz:
             ["mpv", "--no-video", "--really-quiet", str(arquivo)],
             ["cvlc", "--play-and-exit", "--intf", "dummy", str(arquivo)],
         ]
+        env = dados_tela.envelope(arquivo)        # volume real da fala dele: barras da tela e luz do teclado seguem
         for cmd in tentativas:
             try:
                 p = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
             except (FileNotFoundError, OSError):
                 continue
+            t0 = time.time()
             while p.poll() is None:
+                if env:
+                    i = int((time.time() - t0) / 0.05)
+                    nv = env[i] if i < len(env) else 0.0
+                    self.bolinha.estado("falando", nv)
+                    self.luz.mudar("falando", nv)
                 if self._parar_fala.is_set() or not self._vivo:
                     try:
                         p.terminate()
@@ -332,16 +564,36 @@ class Voz:
                 continue
             tipo = msg.get("tipo")
             if tipo == "falar":
-                self._falas.put(str(msg.get("texto") or ""))
+                texto = str(msg.get("texto") or "")
+                if msg.get("bruto"):
+                    # a voz resume; o texto inteiro (código, listas) vai ao painel
+                    fala, tela = conversa.resumo(texto)
+                    self.bolinha.enviar({"resposta": tela[:700]})
+                    texto = conversa.frase_final(fala)
+                    self._acordado_ate = time.time() + 25
+                self._falas.put(texto)
+            elif tipo == "ferramenta":
+                self.maquina.mandar("ferramenta")
+                self._estado("executando")
+                conf = conversa.confirmacao(msg.get("nome", ""), msg.get("args"))
+                if conf and time.time() - self._ultima_conf > 8 and not self._falando:
+                    self._ultima_conf = time.time()
+                    self._falas.put(conf)
             elif tipo == "calar":
                 self._parar_fala.set()
-                while not self._falas.empty():
-                    try:
-                        self._falas.get_nowait()
-                    except queue.Empty:
-                        break
+                self._limpar_falas()
             elif tipo == "estado":
-                self.bolinha.estado(str(msg.get("estado") or "esperando"))
+                est = str(msg.get("estado") or "esperando")
+                if est == "erro":
+                    self._erro("Deu ruim. O detalhe está no terminal.")
+                    est = "ouvindo"
+                self.maquina.mandar("sem_fala")
+                self._estado("ouvindo" if est == "esperando" and time.time() < self._acordado_ate else
+                             ("dormindo" if est == "esperando" else est))
+                if est == "esperando":
+                    self.sons.tocar("pronto", falando=self._falando)
+            elif tipo == "painel":
+                self.bolinha.enviar({"painel": msg.get("acao", "alternar")})
             elif tipo == "fim":
                 break
         self.parar()
@@ -351,6 +603,7 @@ class Voz:
             return
         self._vivo = False
         self._parar_fala.set()
+        self.luz.fechar()
         self.bolinha.fechar()
         falar_para_o_node({"tipo": "fim"})