primocode 10.14.1 → 10.15.1

package/voz/primo_voz/conversa.py

@@ -0,0 +1,236 @@
+"""conversa.py — a lógica da conversa, sem microfone, sem tela e sem som.
+
+Tudo aqui é puro (entra texto/evento, sai decisão), de propósito: é o que o
+teste mede. O que toca hardware (escuta.py, hud.py, __main__.py) só chama isto.
+
+    Maquina    ouvindo → pensando → falando → (interrompido) → ouvindo
+    Fatiador   texto em streaming → frases prontas para falar
+    resumo     resposta longa → (fala curta, o que vai para o painel)
+    ativacao   "Primo, abre o projeto" → (True, "abre o projeto")
+    comando    "esconde o painel" → "esconder"
+    confirmacao  ferramenta → "rodando os testes"
+"""
+from __future__ import annotations
+
+import re
+import unicodedata
+from typing import List, Optional, Tuple
+
+
+def _sem_acento(s: str) -> str:
+    return "".join(ch for ch in unicodedata.normalize("NFD", s) if unicodedata.category(ch) != "Mn")
+
+
+def normalizar(s: str) -> str:
+    """minúsculo, sem acento, sem pontuação — para comparar o que o Whisper deu."""
+    s = _sem_acento(str(s or "").lower())
+    return re.sub(r"\s+", " ", re.sub(r"[^a-z0-9 ]+", " ", s)).strip()
+
+
+# ── a máquina de estados ─────────────────────────────────────────────────
+
+ESTADOS = ("dormindo", "ouvindo", "pensando", "falando", "executando", "interrompido")
+
+# evento → {estado de origem → estado novo}. O que não está aqui é ignorado
+# (um evento fora de hora não pode quebrar a conversa).
+TRANSICOES = {
+    "ativar":     {"dormindo": "ouvindo", "ouvindo": "ouvindo"},
+    "dormir":     {"ouvindo": "dormindo", "interrompido": "dormindo"},
+    "ouviu":      {"ouvindo": "pensando", "interrompido": "pensando", "dormindo": "pensando"},
+    "ferramenta": {"pensando": "executando", "executando": "executando", "falando": "falando"},
+    "resposta":   {"pensando": "falando", "executando": "falando", "ouvindo": "falando"},
+    "fim_fala":   {"falando": "ouvindo", "interrompido": "ouvindo"},
+    "sem_fala":   {"pensando": "ouvindo", "executando": "ouvindo"},
+    "cortou":     {"falando": "interrompido"},
+    "escutar":    {"interrompido": "ouvindo"},
+    "parar":      {"pensando": "ouvindo", "executando": "ouvindo", "falando": "ouvindo", "interrompido": "ouvindo"},
+}
+
+
+class Maquina:
+    """O estado da conversa. `mandar(evento)` devolve o estado novo."""
+
+    def __init__(self, inicial: str = "ouvindo") -> None:
+        self.estado = inicial
+        self.historico: List[str] = [inicial]
+
+    def mandar(self, evento: str) -> str:
+        novo = TRANSICOES.get(evento, {}).get(self.estado)
+        if novo and novo != self.estado:
+            self.estado = novo
+            self.historico.append(novo)
+        return self.estado
+
+    @property
+    def pode_cortar(self) -> bool:
+        """Falar por cima só corta se ele está falando."""
+        return self.estado == "falando"
+
+
+# ── frase a frase ────────────────────────────────────────────────────────
+
+_FIM = re.compile(r"(?<=[.!?…])\s+|(?<=\n)")
+_ABREV = re.compile(r"\b(sr|sra|dr|dra|etc|ex|obs|vs|p\.ex)\.$", re.I)
+
+
+class Fatiador:
+    """Recebe texto aos pedaços (streaming) e devolve frases completas.
+
+    Frase curta demais não sai sozinha (a voz picotada soa pior que a espera):
+    gruda na seguinte. A primeira frase sai mais cedo (mínimo menor), porque é
+    ela que decide quanto tempo a pessoa espera até ouvir algo."""
+
+    def __init__(self, minimo: int = 24, minimo_primeira: int = 12) -> None:
+        self.buf = ""
+        self.minimo = minimo
+        self.minimo_primeira = minimo_primeira
+        self.saiu = 0
+
+    def _alvo(self) -> int:
+        return self.minimo_primeira if self.saiu == 0 else self.minimo
+
+    def alimentar(self, pedaco: str) -> List[str]:
+        self.buf += pedaco or ""
+        return self._tirar(final=False)
+
+    def fechar(self) -> List[str]:
+        return self._tirar(final=True)
+
+    def _tirar(self, final: bool) -> List[str]:
+        saida: List[str] = []
+        partes = _FIM.split(self.buf)
+        resto = partes.pop() if partes else ""
+        acumulado = ""
+        for p in partes:
+            acumulado = (acumulado + " " + p).strip() if acumulado else p.strip()
+            if _ABREV.search(acumulado):
+                continue
+            if len(acumulado) >= self._alvo():
+                saida.append(acumulado)
+                self.saiu += 1
+                acumulado = ""
+        self.buf = (acumulado + " " + resto).strip() if acumulado else resto
+        if final and self.buf.strip():
+            saida.append(self.buf.strip())
+            self.saiu += 1
+            self.buf = ""
+        return saida
+
+
+def dividir_frases(texto: str) -> List[str]:
+    f = Fatiador()
+    return f.alimentar(texto) + f.fechar()
+
+
+# ── o que vai para o ouvido e o que vai para o painel ────────────────────
+
+def limpar_para_voz(texto: str) -> str:
+    t = str(texto or "")
+    t = re.sub(r"```[\s\S]*?```", " ", t)
+    t = re.sub(r"\s+(em|no|na|de|do|da|para)\s+`[^`]*[/\\.][^`]*`", "", t)
+    t = re.sub(r"`([^`]*)`", lambda m: "" if re.search(r"[/\\.]", m.group(1)) else m.group(1), t)
+    t = re.sub(r"https?://\S+", "", t)
+    t = re.sub(r"(^|\s)[~.]?/[\w.\-/]+", " ", t)
+    t = re.sub(r"^\s*(#+|[-*•]|\d+[.)])\s+", "", t, flags=re.M)
+    t = re.sub(r"[*_>|]", "", t)
+    return re.sub(r"\s+", " ", t).strip()
+
+
+def resumo(texto: str, frases: int = 2, teto: int = 260) -> Tuple[str, str]:
+    """(fala, painel). A voz resume; o texto inteiro (código, listas) vai ao painel."""
+    painel = str(texto or "").strip()
+    limpo = limpar_para_voz(painel)
+    partes = [p.strip() for p in re.findall(r"[^.!?…]+[.!?…]*", limpo) if p.strip()]
+    fala = ""
+    for p in partes[:frases]:
+        if len(fala) + len(p) > teto:
+            break
+        fala = (fala + " " + p).strip()
+    if not fala:
+        fala = limpo[:teto].strip()
+    tinha_mais = bool(re.search(r"```", painel)) or len(partes) > frases
+    if tinha_mais and fala and not re.search(r"painel|tela", fala, re.I):
+        fala += " O resto está no painel."
+    return fala, painel
+
+
+# ── a palavra de ativação ────────────────────────────────────────────────
+
+_NOMES = ("primo", "primu", "prima", "primocode", "primo code")
+_ANTES = ("ei", "ey", "hey", "oi", "ola", "fala", "e ai", "opa", "salve")
+
+
+def ativacao(texto: str, nome: str = "Primo") -> Tuple[bool, str]:
+    """Começa com "Primo" (ou "ei Primo")? Devolve (sim?, o resto do pedido).
+
+    Só vale no INÍCIO da fala: "o primo da Ana ligou" não acorda ninguém."""
+    cru = str(texto or "").strip()
+    n = normalizar(cru)
+    meus = _NOMES if normalizar(nome) in ("primo", "") else (normalizar(nome),)
+    for ant in ("",) + _ANTES:
+        for nm in meus:
+            pre = (ant + " " + nm).strip()
+            if n == pre or n.startswith(pre + " "):
+                resto = re.sub(r"^\W*(?:" + r"\W+".join(re.escape(w) for w in pre.split()) + r")\W*", "",
+                               _sem_acento(cru), flags=re.I)
+                # o corte vale no texto sem acento; o tamanho é o mesmo
+                resto = cru[len(cru) - len(resto):] if len(resto) <= len(cru) else resto
+                return True, resto.strip(" ,.!?;:-")
+    return False, cru
+
+
+# ── comandos de voz que o painel e o modo resolvem sozinhos ──────────────
+
+_COMANDOS = [
+    ("esconder", r"(esconde|esconder|some com|fecha|oculta) (o )?(painel|hud)"),
+    ("mostrar", r"(mostra|mostrar|abre|exibe|volta com) (o )?(painel|hud)"),
+    ("parar", r"(para|pare|calma|chega|cala a boca|silencio|cancela)"),
+    ("olhar", r"(olha aqui|olha isso|olha a tela|veja a tela|ve a tela|olha pra tela|ve isso)"),
+    ("resumo_dia", r"(resumo do dia|como foi o dia|resumo de hoje|briefing|o que mudou hoje)"),
+]
+
+
+def comando(texto: str) -> Optional[str]:
+    n = normalizar(texto)
+    if not n or len(n.split()) > 6:      # comando é curto; frase longa é pedido
+        return None
+    for nome, rx in _COMANDOS:
+        if re.fullmatch(rx + r"( por favor| ai| agora)?", n):
+            return nome
+    return None
+
+
+# ── confirmações curtas de ação ──────────────────────────────────────────
+
+def confirmacao(ferramenta: str, args: Optional[dict] = None) -> str:
+    """O que o Primo diz ao começar uma ferramenta. Vazio = não diz nada."""
+    f = str(ferramenta or "")
+    cmd = str((args or {}).get("command") or "")
+    if f == "run_shell":
+        if re.search(r"\b(test|jest|pytest|vitest)\b", cmd):
+            return "Rodando os testes."
+        if re.search(r"\bgit\s+(push|commit)\b", cmd):
+            return "Mandando pro git."
+        if re.search(r"\b(build|tsc)\b", cmd):
+            return "Fazendo o build."
+        return "Rodando."
+    if f in ("desktop_open_app",):
+        return "Abrindo."
+    if f in ("write_file", "edit_file", "apply_patch"):
+        return "Editando."
+    if f in ("web_search", "pesquisar_referencia"):
+        return "Pesquisando."
+    return ""
+
+
+def rotulo_ferramenta(ferramenta: str, args: Optional[dict] = None) -> str:
+    """O texto do painel: ferramenta + alvo curto."""
+    a = args or {}
+    alvo = a.get("path") or a.get("command") or a.get("query") or a.get("url") or ""
+    alvo = re.sub(r"\s+", " ", str(alvo)).strip()
+    return (str(ferramenta) + (" · " + alvo[:48] if alvo else ""))[:70]
+
+
+def frase_final(texto: str) -> str:
+    """Termina a fala de ação com um 'feito' quando a resposta não tem fala."""
+    return texto if texto.strip() else "Feito."

package/voz/primo_voz/escuta.py

@@ -30,6 +30,7 @@ from __future__ import annotations
 
 import threading
 import time
+import os
 import wave
 from pathlib import Path
 from typing import List, Optional
@@ -46,9 +47,10 @@ TETO_FALA = 700.0          # nunca exige mais que isso (não ficar surdo)
 FATOR_CONTINUAR = 0.5      # a histerese: depois de começar, o limiar cai
 PRE_ROLL = 4               # blocos guardados ANTES do início da fala
 
-RABO_SILENCIO = 2.0        # silêncio que encerra a frase
-RABO_SILENCIO_LONGA = 2.8  # …e quando a fala já vem longa
+RABO_SILENCIO = 1.0        # silêncio que encerra a frase
+RABO_SILENCIO_LONGA = 1.5  # …e quando a fala já vem longa
 FALA_LONGA = 6.0
+RABO_VAD = 0.5            # silêncio que encerra a frase quando o VAD confirma
 ESPERA_COMECAR = 8.0       # tempo para a pessoa começar a falar
 MAX_FRASE = 45.0
 MAX_FRASE_ESTENDIDA = 100.0
@@ -93,6 +95,9 @@ class Gravador:
         self._ambiente = PISO_FALA
         self._amostras_ambiente: List[float] = []
         self.encerrou_por = ""
+        # VAD opcional (Silero, via pysilero-vad): bloco → True se for voz.
+        # Com ele, a frase fecha em 0,9 s de silêncio em vez de 2 s.
+        self.vad = None
 
     # O ambiente é medido ENQUANTO ele espera a pessoa começar. Medir antes de
     # abrir o microfone daria o silêncio do processo, não o do cômodo.
@@ -114,6 +119,12 @@ class Gravador:
         self._relogio += BLOCO_MS / 1000.0
         agora = self._relogio
         nivel = rms(bloco)
+        voz = None
+        if self.vad is not None:
+            try:
+                voz = bool(self.vad(bloco))
+            except Exception:
+                self.vad = None
 
         if not self._falando:
             # Guarda os últimos blocos: sem eles, a frase começa cortada na
@@ -128,7 +139,7 @@ class Gravador:
             if len(self._amostras_ambiente) >= 5:
                 self._ambiente = float(np.median(self._amostras_ambiente))
 
-            if nivel > self._limiar():
+            if nivel > self._limiar() and voz is not False:
                 self._falando = True
                 self._blocos = list(self._pre)
                 self._ultimo_som = agora
@@ -138,11 +149,13 @@ class Gravador:
             return False
 
         self._blocos.append(bloco)
-        if nivel > self._limiar():
+        if voz is True or (voz is None and nivel > self._limiar()):
             self._ultimo_som = agora
 
         duracao = len(self._blocos) * BLOCO_MS / 1000.0
         rabo = RABO_SILENCIO_LONGA if duracao > FALA_LONGA else RABO_SILENCIO
+        if self.vad is not None:
+            rabo = RABO_VAD
 
         if agora - self._ultimo_som > rabo:
             self.encerrou_por = "silencio"
@@ -216,7 +229,28 @@ class Microfone:
         self._ao_receber = ao_receber
         self._fluxo = None
 
+    def _abrir_de_arquivo(self, caminho: str) -> None:
+        """Modo de teste (PRIMOCODE_TESTE_WAV): em vez do microfone, toca um WAV 16 kHz mono na mesma entrada,
+        depois de 12 s de silêncio (a saudação termina e o motor assenta) e com silêncio no fim."""
+        import threading
+        import time as _t
+        import numpy as _np
+
+        def alimentar():
+            with wave.open(caminho, "rb") as w:
+                dados = _np.frombuffer(w.readframes(w.getnframes()), dtype=_np.int16)
+            _t.sleep(float(os.environ.get("PRIMOCODE_TESTE_ATRASO", "12")))
+            silencio = _np.zeros(BLOCO, dtype=_np.int16)
+            for i in range(0, len(dados) + BLOCO * 20, BLOCO):
+                bloco = dados[i:i + BLOCO]
+                self._ao_receber(bloco if len(bloco) == BLOCO else (_np.concatenate([bloco, silencio])[:BLOCO]))
+                _t.sleep(BLOCO_MS / 1000)
+        threading.Thread(target=alimentar, daemon=True).start()
+
     def abrir(self) -> None:
+        if os.environ.get("PRIMOCODE_TESTE_WAV"):
+            return self._abrir_de_arquivo(os.environ["PRIMOCODE_TESTE_WAV"])
+
         def retorno(dados, quadros, tempo, estado):  # noqa: ARG001
             self._ao_receber(dados[:, 0].copy())
 
@@ -234,3 +268,21 @@ class Microfone:
             except Exception:
                 pass
             self._fluxo = None
+
+
+def criar_vad():
+    """O detector de voz Silero (MIT, pysilero-vad, só onnx/ggml) ou None se não instalou."""
+    try:
+        from pysilero_vad import SileroVoiceActivityDetector
+        det = SileroVoiceActivityDetector()
+    except Exception:
+        return None
+    passo = det.chunk_samples()
+
+    def vad(bloco: np.ndarray) -> bool:
+        pcm = bloco.astype(np.int16)
+        pico = 0.0
+        for i in range(0, len(pcm) - passo + 1, passo):
+            pico = max(pico, det(pcm[i:i + passo].tobytes()))
+        return pico > 0.5
+    return vad

package/voz/primo_voz/fala.py

@@ -0,0 +1,87 @@
+"""fala.py — a voz do Primo: Edge TTS (neural pt-BR) dentro do processo, sem subprocesso por frase.
+
+Ordem: Edge TTS (precisa de internet) → ElevenLabs só se a pessoa pediu (`"tts": "elevenlabs"` em
+~/.primocode/voz.json) → voz do sistema (`say`) offline. As vozes: francisca (padrão), antonio, thalita.
+O event loop e o import do edge_tts ficam vivos na thread `Edge`; cada frase é uma tarefa nele.
+"""
+from __future__ import annotations
+
+import asyncio
+import threading
+import unicodedata
+from pathlib import Path
+from typing import Optional
+
+VOZES = {"francisca": "pt-BR-FranciscaNeural", "antonio": "pt-BR-AntonioNeural", "thalita": "pt-BR-ThalitaMultilingualNeural"}
+ORDEM = ["francisca", "antonio", "thalita"]
+
+
+def _s(t: str) -> str:
+    return "".join(c for c in unicodedata.normalize("NFD", t.lower()) if unicodedata.category(c) != "Mn")
+
+
+def voz_pedida(texto: str, atual: str) -> Optional[str]:
+    """"muda a voz" / "troca a voz para antonio" → o id da nova voz (a próxima da lista, se não disse qual); None se não era isso."""
+    import re
+    m = re.search(r"\b(?:muda|mudar|troca|trocar|mude|troque)\s+(?:a\s+)?voz(?:\s+(?:para|pra|pro|do|da|de)\s+(?:a\s+|o\s+)?(\w+))?", _s(texto))
+    if not m:
+        return None
+    pedida = m.group(1)
+    if pedida and pedida in VOZES:
+        return pedida
+    i = ORDEM.index(atual) if atual in ORDEM else -1
+    return ORDEM[(i + 1) % len(ORDEM)]
+
+
+class Edge:
+    def __init__(self) -> None:
+        self.ok = False
+        self._loop: "asyncio.AbstractEventLoop | None" = None
+        self._pronto = threading.Event()
+        threading.Thread(target=self._rodar, daemon=True).start()
+
+    def _rodar(self) -> None:
+        try:
+            import edge_tts  # noqa: F401
+            self.ok = True
+        except ImportError:
+            self._pronto.set()
+            return
+        self._loop = asyncio.new_event_loop()
+        self._pronto.set()
+        self._loop.run_forever()
+
+    async def _tarefa(self, texto: str, voz: str, saida: Path) -> bool:
+        import edge_tts
+        n = 0
+        with open(saida, "wb") as f:
+            async for c in edge_tts.Communicate(texto, voz, rate="+8%").stream():
+                if c["type"] == "audio":
+                    f.write(c["data"])
+                    n += len(c["data"])
+        return n > 0
+
+    def sintetizar(self, texto: str, voz_id: str, saida: Path, limite: float = 15.0) -> bool:
+        self._pronto.wait(5)
+        if not self.ok or not self._loop:
+            return False
+        try:
+            fut = asyncio.run_coroutine_threadsafe(self._tarefa(texto, VOZES.get(voz_id, VOZES["francisca"]), saida), self._loop)
+            return bool(fut.result(limite))
+        except Exception:
+            return False
+
+    def aquecer(self) -> None:
+        """Uma frase curta descartada: abre DNS, TLS e o módulo antes da primeira fala de verdade."""
+        import tempfile
+        p = Path(tempfile.gettempdir()) / "primo-voz-aquece.mp3"
+        self.sintetizar("oi", "francisca", p)
+        try:
+            p.unlink()
+        except OSError:
+            pass
+
+
+def hora_falada(t) -> str:
+    """"São 19 e 05." — o mesmo texto no app.py (resposta) e no motor (pré-voz do próximo minuto)."""
+    return f"São {t.tm_hour} e {t.tm_min:02d}." if t.tm_min else f"São {t.tm_hour} horas em ponto."