primocode 9.9.0 → 10.0.0

package/voz/primo_voz/__main__.py

@@ -1,40 +1,31 @@
-"""primo_voz — o Primo Code em modo voz.
+"""primo_voz — o ouvido e a boca do PrimoCode. Não tem cérebro.
 
-    "/voice abre o Primo Code em modo voz. Ele abre como um aplicativozinho,
-     não como uma janela de terminal comum. Base: a lógica do Jarvis, que já
-     funciona. Não roda mais com Claude por baixo: usa o modelo selecionado
-     nos conectores do Primo Code."
+    "As funções do modo voz serão implementadas na CLI; o modo voz será só
+     para falar e ele responder em voz alta."
 
-── A DECISÃO QUE DEFINE ESTE ARQUIVO ───────────────────────────────────────
-Este programa NÃO tem cérebro. Ele ouve, transcreve, fala e desenha a orb — e
-manda o texto para o PrimoCode, que é quem pensa.
+── O QUE ESTE PROCESSO FAZ ─────────────────────────────────────────────────
+Ouve o microfone, transcreve o que a pessoa disse e entrega o TEXTO ao
+terminal, que trata como se tivesse sido digitado: vai para a mesma fila, a
+mesma caixa de recados (lib/act.js), o mesmo roteador de conversa. Quando o
+terminal manda falar, ele fala — e cala na hora se a pessoa falar por cima.
 
-O caminho óbvio era portar o cérebro para cá: o Jarvis fazia isso, mantendo
-uma sessão do Claude Code num processo filho. Copiar aquilo significaria uma
-segunda implementação do laço do agente, das trinta ferramentas, do portão de
-permissão do computador e da corrente de conectores — em outra linguagem. Duas
-implementações do mesmo laço é a garantia de que uma delas está errada, e de
-que a correção de amanhã vai para só uma.
-
-Então o cérebro é UM, e é o mesmo do terminal: o `lib/act.js`. Falar com ele
-custa uma linha de JSON no stdout. E é isto que faz o pedido ser cumprido sem
-gambiarra — "usa o modelo selecionado nos conectores do Primo Code" não é uma
-integração a construir: é consequência de o cérebro ser o Primo Code.
+O que saiu (10.0): a orb (uma janela Tk ao lado do terminal), o "ei, primo"
+(o Vosk, um download de 31 MB para um microfone que já está aberto) e o
+cérebro paralelo — o /voice chamava o agente por conta própria, ao lado do
+terminal, e dois agentes na mesma pasta escreviam um por cima do outro.
 
 ── O PROTOCOLO ─────────────────────────────────────────────────────────────
-Uma linha de JSON por mensagem, nas duas direções.
+Uma linha de JSON por mensagem.
 
-    para o Node:  {"tipo":"pedido","texto":"..."}   {"tipo":"fim"}
-    do Node:      {"tipo":"estado","estado":"pensando"}
-                  {"tipo":"resposta","texto":"..."}
+    para o Node:  {"tipo":"pronto"}                o microfone abriu
+                  {"tipo":"ouvi","texto":"..."}    a pessoa disse isto
                   {"tipo":"erro","texto":"..."}
-
-── O QUE FOI REMOVIDO DO JARVIS ────────────────────────────────────────────
-A wake word "Jarvis" e as variantes dela, a saudação com o nome do dono, a
-pasta "Jarvis Workspace", as preferências pessoais, o gesto de câmera, o
-cursor próprio, a barra de comando e a janela de conversa. O que sobra é o que
-é do produto: ouvir, pensar, falar.
+                  {"tipo":"fim"}
+    do Node:      {"tipo":"falar","texto":"..."}   diga isto em voz alta
+                  {"tipo":"calar"}                 pare de falar agora
+                  {"tipo":"fim"}
 """
+
 from __future__ import annotations
 
 import json
@@ -50,7 +41,7 @@ from pathlib import Path
 AQUI = Path(__file__).resolve().parent
 sys.path.insert(0, str(AQUI.parent))
 
-from primo_voz import desperta, escuta, orbe, transcrever  # noqa: E402
+from primo_voz import escuta, transcrever  # noqa: E402
 
 
 def falar_para_o_node(obj: dict) -> None:
@@ -65,30 +56,22 @@ def avisar(texto: str) -> None:
     sys.stderr.flush()
 
 
-# O PowerShell que toca MP3 no Windows. MediaPlayer é assíncrono: Play()
-# devolve na hora, então é preciso esperar a duração — e esperar com teto, ou
-# um Open que falha deixaria a thread da fala pendurada para sempre.
 def motivo_da_narracao(r) -> str:
-    """O que o narrar.py disse que houve — em vez do código de saída.
-
-    Ele responde JSON em stdout, com "error" e "comoResolver". Quando esse
-    JSON não vem (o processo morreu antes de escrever), sobra o stderr, que
-    ainda diz mais que "returned non-zero exit status 1".
-    """
+    """O que o narrar.py disse que houve — em vez do código de saída."""
     try:
         d = json.loads((r.stdout or b"").decode("utf-8", "replace"))
         if isinstance(d, dict) and d.get("error"):
-            comoResolver = d.get("comoResolver") or ""
-            return "não deu para gerar a voz: " + str(d["error"]) + (
-                " — " + str(comoResolver) if comoResolver else "")
+            como = d.get("comoResolver") or ""
+            return "não deu para gerar a voz: " + str(d["error"]) + (" — " + str(como) if como else "")
     except Exception:
         pass
     erro = (r.stderr or b"").decode("utf-8", "replace").strip()
     ultima = erro.splitlines()[-1] if erro else ""
-    return "não deu para gerar a voz" + (f": {ultima[:300]}" if ultima else
-                                         f" (o narrar.py saiu com {r.returncode})")
+    return "não deu para gerar a voz" + (f": {ultima[:300]}" if ultima else f" (o narrar.py saiu com {r.returncode})")
 
 
+# O PowerShell que toca MP3 no Windows. MediaPlayer é assíncrono: Play()
+# devolve na hora, então é preciso esperar a duração — com teto.
 PS_TOCAR_MP3 = (
     "Add-Type -AssemblyName PresentationCore; "
     "$p = New-Object System.Windows.Media.MediaPlayer; "
@@ -104,37 +87,12 @@ PS_TOCAR_MP3 = (
 
 
 class Voz:
-    """A costura: microfone → transcrição → Node → voz → microfone."""
+    """Microfone → transcrição → terminal. Terminal → voz."""
 
-    def __init__(self, servidor: str, token: str, voz_escolhida: str = "antonio",
-                 esperando: bool = False):
+    def __init__(self, servidor: str, token: str, voz_escolhida: str = "antonio"):
         self.servidor = servidor
         self.token = token
         self.voz = voz_escolhida
-
-        # ── MODO DE ESPERA ───────────────────────────────────────────
-        #
-        # Ligado, ele fica dormindo com a orbe escondida até ouvir o nome, e
-        # volta a dormir depois de atender. Desligado (o padrão antigo), ele
-        # já entra ouvindo — que é o certo para quem digitou /voice e vai
-        # falar agora.
-        #
-        # A espera exige o reconhecedor local. Sem ele instalado, não cai
-        # para "mandar tudo para o servidor": cai para o modo de sempre, e
-        # DIZ por quê. Silenciosamente transformar uma coisa na outra seria
-        # abrir o microfone da pessoa para a internet sem ela saber.
-        #
-        self.esperando = bool(esperando)
-        self.desperta = None
-        if self.esperando:
-            self.desperta = desperta.Desperta(ao_despertar=lambda: None)
-            if not self.desperta.pronto:
-                avisar(f"modo de espera indisponível: {self.desperta.motivo} — "
-                       "abrindo no modo normal, já ouvindo.")
-                self.esperando = False
-                self.desperta = None
-
-        self.orb = orbe.Orbe(ao_fechar=self.parar)
         # O Whisper local carrega em segundo plano desde já: senão a primeira
         # frase esperaria o modelo inteiro subir.
         self.local = transcrever.disponivel()
@@ -142,125 +100,68 @@ class Voz:
             transcrever.aquecer()
         self.gravador = escuta.Gravador()
         self.corte = escuta.Corte()
-
-        self._blocos = queue.Queue()
+        self._blocos: "queue.Queue" = queue.Queue()
+        self._falas: "queue.Queue" = queue.Queue()
         self._vivo = True
         self._falando = False
-        self._pensando = False
         self._parar_fala = threading.Event()
-        self._do_node = queue.Queue()
-
-    def _esvaziar_blocos(self) -> None:
-        """Joga fora o áudio que está na fila.
 
-        Depois de despertar, os blocos do próprio "ei primo" ainda estão
-        enfileirados — e sem isto eles entram na gravação do PEDIDO, que chega
-        ao agente com o nome colado na frente.
-        """
-        while True:
-            try:
-                self._blocos.get_nowait()
-            except queue.Empty:
-                return
+    # ── o ouvido ─────────────────────────────────────────────────────────
 
-    # ── microfone ────────────────────────────────────────────────────────
     def _ao_receber(self, bloco) -> None:
         if not self._vivo:
             return
         nivel = escuta.rms(bloco)
-
-        # Falar por cima CORTA a resposta. Sem isto, a única forma de
-        # interromper é esperar ele terminar — e esperar um assistente
-        # terminar de falar uma coisa errada é a pior parte de usar um.
+        # 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 self._falando:
             self.corte.ele_falou(nivel)
             if self.corte.alguem_cortou(nivel):
                 self._parar_fala.set()
             return
-
         self._blocos.put(bloco)
-        if self.orb:
-            self.orb.mudar(nivel=min(1.0, nivel / 2500.0))
 
-    # ── o laço ───────────────────────────────────────────────────────────
-    def _laco(self) -> None:
+    def _esvaziar_blocos(self) -> None:
+        while True:
+            try:
+                self._blocos.get_nowait()
+            except queue.Empty:
+                return
+
+    def _ouvir(self) -> None:
         mic = escuta.Microfone(self._ao_receber)
         try:
             mic.abrir()
         except Exception as e:
-            avisar(f"não consegui abrir o microfone: {e}")
-            falar_para_o_node({"tipo": "erro", "texto": f"microfone: {e}"})
+            falar_para_o_node({"tipo": "erro", "texto": f"não consegui abrir o microfone: {e}"})
             self.parar()
             return
-
+        falar_para_o_node({"tipo": "pronto"})
         while self._vivo:
-            # ── O SONO ───────────────────────────────────────────────
-            # No modo de espera a orbe some e o microfone fica ouvindo SÓ o
-            # nome, aqui dentro, sem nada sair da máquina (ver desperta.py).
-            # Sem isso, o modo de espera seria o microfone da pessoa aberto
-            # para a internet o dia inteiro.
-            if self.esperando and self.desperta is not None:
-                self.orb.esconder()
-                self.desperta.zerar()
-                acordou = False
-                while self._vivo and not acordou:
-                    try:
-                        bloco = self._blocos.get(timeout=0.3)
-                    except queue.Empty:
-                        continue
-                    acordou = self.desperta.alimentar(bloco)
-                if not self._vivo:
-                    break
-                # Chamou: a orbe aparece e ele passa a ouvir o PEDIDO.
-                self.orb.mostrar()
-                self.orb.mudar(estado="ouvindo", nivel=0)
-                # Sem esvaziar a fila, os blocos do próprio "ei primo" entram
-                # na gravação do pedido — e o pedido chega com o nome colado
-                # na frente.
-                self._esvaziar_blocos()
-
-            self.orb.mudar(estado="esperando", nivel=0)
             self.gravador.comecar()
-
-            # Esperar a frase.
             acabou = False
             while self._vivo and not acabou:
                 try:
                     bloco = self._blocos.get(timeout=0.3)
                 except queue.Empty:
                     continue
-                if self.gravador._falando:
-                    self.orb.mudar(estado="ouvindo")
                 acabou = self.gravador.alimentar(bloco)
-
             if not self._vivo:
                 break
             if self.gravador.encerrou_por == "ninguem-falou" or self.gravador.segundos < 0.4:
                 continue
-
             wav = self.gravador.gravar_wav(Path(tempfile.gettempdir()) / "primo-voz-fala.wav")
             if not wav:
                 continue
-
-            self.orb.mudar(estado="pensando")
-            # O servidor também transcreve com Whisper: a mesma limpeza vale.
             texto = transcrever.limpar(self._transcrever(wav))
-            if not texto:
-                self.orb.mudar(estado="esperando")
-                continue
-
-            falar_para_o_node({"tipo": "pedido", "texto": texto})
-            resposta = self._esperar_resposta()
-            if resposta:
-                self._falar(resposta)
-
+            if texto:
+                falar_para_o_node({"tipo": "ouvi", "texto": texto})
         mic.fechar()
 
-    # ── transcrição ──────────────────────────────────────────────────────
     def _transcrever(self, wav: Path) -> str:
-        """Primeiro aqui, com o Whisper local (ver transcrever.py). O servidor
-        só entra se o local não estiver instalado ou falhar — e diz que caiu.
-        """
+        """Primeiro aqui, com o Whisper local. O servidor só entra se o local
+        não estiver instalado ou falhar — e diz que caiu."""
         if self.local:
             try:
                 return transcrever.transcrever(wav)
@@ -269,13 +170,8 @@ class Voz:
         return self._transcrever_no_servidor(wav)
 
     def _transcrever_no_servidor(self, wav: Path) -> str:
-        """A rota do servidor, a mesma que a legenda de vídeo usa."""
         import base64
         import urllib.request
-
-        # O wav de 16 kHz mono já é pequeno; converter para mp3 exigiria
-        # ffmpeg, que nem toda máquina tem — e uma frase de dez segundos cabe
-        # em ~300 KB, que atravessa a rede sem dor.
         dados = base64.b64encode(wav.read_bytes()).decode("ascii")
         corpo = json.dumps({"audio": dados, "nome": "fala.wav", "idioma": "pt"}).encode("utf-8")
         pedido = urllib.request.Request(
@@ -291,100 +187,51 @@ class Voz:
             avisar(f"não deu para transcrever: {e}")
             return ""
 
-    # ── resposta do Node ─────────────────────────────────────────────────
-    def _esperar_resposta(self) -> str:
+    # ── a boca ───────────────────────────────────────────────────────────
+
+    def _falar_em_fila(self) -> None:
         while self._vivo:
             try:
-                msg = self._do_node.get(timeout=0.5)
+                texto = self._falas.get(timeout=0.3)
             except queue.Empty:
                 continue
-            tipo = msg.get("tipo")
-            if tipo == "estado":
-                self.orb.mudar(estado=msg.get("estado") or "pensando")
-            elif tipo == "resposta":
-                return str(msg.get("texto") or "")
-            elif tipo == "erro":
-                return str(msg.get("texto") or "não deu certo")
-            elif tipo == "fim":
-                self.parar()
-                return ""
-        return ""
-
-    def ouvir_o_node(self) -> None:
-        """Lê o stdin, linha a linha, até ele fechar."""
-        for linha in sys.stdin:
-            linha = linha.strip()
-            if not linha:
-                continue
-            try:
-                self._do_node.put(json.loads(linha))
-            except json.JSONDecodeError:
-                continue
-        self.parar()
+            self._falar(texto)
 
-    # ── voz ──────────────────────────────────────────────────────────────
     def _falar(self, texto: str) -> None:
-        """A resposta sai em voz — e SÓ em voz.
-
-        O texto não aparece em lugar nenhum da interface. É a regra do modo:
-        ler a resposta é trabalho, ouvir não é.
-        """
         limpo = " ".join(str(texto).split())
         if not limpo:
             return
-        # Resposta longa demais em voz é castigo: quem ouve não pode passar o
-        # olho. O agente já responde curto no modo voz (o Node manda a
-        # instrução), e isto é a rede embaixo.
         if len(limpo) > 900:
             limpo = limpo[:880].rsplit(" ", 1)[0] + "…"
-
         mp3 = Path(tempfile.gettempdir()) / f"primo-voz-{int(time.time() * 1000)}.mp3"
         narrar = AQUI.parent.parent / "studio" / "narrar.py"
-        # O narrar.py IMPRIME um JSON dizendo o que faltou e como resolver
-        # ("instale o edge-tts com… "). Com check=True isso virava uma
-        # CalledProcessError cujo texto é "Command '[...]' returned non-zero
-        # exit status 1" — e era ISSO que chegava ao usuário, com o conselho
-        # útil jogado fora dentro do capture_output. Agora a saída é lida.
         r = subprocess.run(
-            [sys.executable, str(narrar), "falar", "--texto", limpo,
-             "--saida", str(mp3), "--voz", self.voz],
+            [sys.executable, str(narrar), "falar", "--texto", limpo, "--saida", str(mp3), "--voz", self.voz],
             capture_output=True, timeout=180)
         if r.returncode != 0 or not mp3.exists():
             avisar(motivo_da_narracao(r))
             return
-
         self._falando = True
         self._parar_fala.clear()
-        self.orb.mudar(estado="falando")
         try:
             self._tocar(mp3)
         finally:
             self._falando = False
             self.corte.nivel_dele = 0.0
+            # O que o microfone pegou enquanto ele falava é a voz dele.
+            self._esvaziar_blocos()
             try:
                 mp3.unlink()
             except OSError:
                 pass
 
     def _tocar(self, arquivo: Path) -> None:
-        """Toca o mp3 com o que a máquina tiver.
-
-        Nenhum tocador é garantido em todo sistema, então são vários, na ordem
-        de quem está mais presente — e o processo é interrompível, porque
-        falar por cima precisa calar a voz na hora.
-        """
+        """Toca o mp3 com o que a máquina tiver — interrompível, porque falar
+        por cima precisa calar a voz na hora."""
         tentativas = []
         if sys.platform == "darwin":
             tentativas.append(["afplay", str(arquivo)])
         elif sys.platform == "win32":
-            # Media.SoundPlayer NÃO toca MP3 — ele só lê WAV, e o que o
-            # narrar.py entrega é MP3. Era a primeira tentativa da fila, e
-            # levantava exceção sempre; como o laço abaixo aceitava qualquer
-            # processo que tivesse CONSEGUIDO INICIAR, ele dava por tocado e
-            # voltava. Resultado: o modo voz era MUDO no Windows, sem nenhum
-            # aviso — a orb piscava "falando" e não saía som nenhum.
-            # MediaPlayer decodifica MP3; a espera é limitada para não travar
-            # a thread se o Open falhar.
             tentativas.append(["powershell", "-NoProfile", "-Command", PS_TOCAR_MP3.format(arquivo=arquivo)])
         tentativas += [
             ["ffplay", "-nodisp", "-autoexit", "-loglevel", "quiet", str(arquivo)],
@@ -403,21 +250,43 @@ class Voz:
                         p.terminate()
                     except Exception:
                         pass
-                    return          # calado de propósito: falaram por cima
+                    return
                 time.sleep(0.05)
             if p.returncode == 0:
                 return
-            # INICIAR não é TOCAR. O tocador existia e falhou (formato que ele
-            # não lê, dispositivo de áudio ocupado): a fila continua. Sair aqui
-            # era o que transformava "o primeiro tocador não serve" em silêncio
-            # absoluto, com quatro alternativas por tentar logo abaixo.
+            # INICIAR não é TOCAR: o tocador que abriu e morreu não conta, e o
+            # próximo da fila é tentado.
             continue
-        avisar("não achei um tocador de áudio que funcione neste computador."
-               + (" Instale o ffmpeg: winget install ffmpeg" if sys.platform == "win32"
-                  else " Instale o ffmpeg: brew install ffmpeg" if sys.platform == "darwin"
-                  else " Instale o ffmpeg: sudo apt install ffmpeg"))
+        avisar("não achei um tocador de áudio que funcione neste computador. Instale o ffmpeg"
+               + (": winget install ffmpeg" if sys.platform == "win32"
+                  else ": brew install ffmpeg" if sys.platform == "darwin"
+                  else ": sudo apt install ffmpeg"))
+
+    # ── o terminal ───────────────────────────────────────────────────────
+
+    def ouvir_o_node(self) -> None:
+        for linha in sys.stdin:
+            linha = linha.strip()
+            if not linha:
+                continue
+            try:
+                msg = json.loads(linha)
+            except json.JSONDecodeError:
+                continue
+            tipo = msg.get("tipo")
+            if tipo == "falar":
+                self._falas.put(str(msg.get("texto") or ""))
+            elif tipo == "calar":
+                self._parar_fala.set()
+                while not self._falas.empty():
+                    try:
+                        self._falas.get_nowait()
+                    except queue.Empty:
+                        break
+            elif tipo == "fim":
+                break
+        self.parar()
 
-    # ── ciclo de vida ────────────────────────────────────────────────────
     def parar(self) -> None:
         if not self._vivo:
             return
@@ -426,34 +295,25 @@ class Voz:
         falar_para_o_node({"tipo": "fim"})
 
     def rodar(self) -> None:
-        threading.Thread(target=self._laco, daemon=True).start()
-        threading.Thread(target=self.ouvir_o_node, daemon=True).start()
-        # A interface fica na thread principal, porque em todo sistema é lá
-        # que uma janela pode existir.
-        self.orb.rodar()
+        threading.Thread(target=self._ouvir, daemon=True).start()
+        threading.Thread(target=self._falar_em_fila, daemon=True).start()
+        self.ouvir_o_node()
 
 
 def main() -> int:
     servidor = os.environ.get("PRIMOCODE_SERVER", "").strip()
     token = os.environ.get("PRIMOCODE_TOKEN", "").strip()
     voz = os.environ.get("PRIMOCODE_VOZ", "antonio").strip() or "antonio"
-    # O modo de espera vem por variável, como o resto: quem abre este programa
-    # é o /voice do Node, não uma pessoa numa linha de comando.
-    esperando = os.environ.get("PRIMOCODE_VOZ_ESPERA", "") == "1"
-
     if not servidor:
         avisar("falta PRIMOCODE_SERVER — este programa é aberto pelo /voice do PrimoCode.")
         return 2
-
     try:
         import numpy  # noqa: F401
         import sounddevice  # noqa: F401
     except ImportError as e:
-        avisar(f"falta um pacote de áudio ({e.name}). Rode: "
-               f"{sys.executable} -m pip install sounddevice numpy")
+        avisar(f"falta um pacote de áudio ({e.name}). Rode: {sys.executable} -m pip install sounddevice numpy")
         return 3
-
-    Voz(servidor, token, voz, esperando=esperando).rodar()
+    Voz(servidor, token, voz).rodar()
     return 0
 
 

package/voz/primo_voz/transcrever.py

@@ -119,10 +119,40 @@ def transcrever(wav: Path, idioma: str = "pt") -> str:
     return limpar(" ".join(s.text.strip() for s in segmentos if aproveitavel(s)))
 
 
+def palavras(arquivo: str, idioma: str = "pt") -> list:
+    """Cada palavra com o tempo dela, no formato do /api/transcrever
+    ({de, ate, texto}). É o que o editor de vídeo usa para legenda e para
+    apagar palavra (lib/video/transcript.js)."""
+    modelo = carregar()
+    segmentos, _ = modelo.transcribe(str(arquivo), language=idioma, beam_size=5, word_timestamps=True,
+                                     vad_filter=True, condition_on_previous_text=False)
+    out = []
+    for s in segmentos:
+        if not aproveitavel(s):
+            continue
+        for w in (s.words or []):
+            texto = (w.word or "").strip()
+            if texto:
+                out.append({"de": round(float(w.start), 3), "ate": round(float(w.end), 3), "texto": texto})
+    return out
+
+
 def main() -> int:
     """`python -m primo_voz.transcrever baixar` — usado pelo /voice para deixar
-    o modelo pronto antes da primeira frase. Responde uma linha de JSON."""
+    o modelo pronto antes da primeira frase. Responde uma linha de JSON.
+    `... palavras <arquivo> [idioma]` devolve as palavras com tempo."""
     acao = sys.argv[1] if len(sys.argv) > 1 else "baixar"
+    if acao == "palavras":
+        if not disponivel():
+            print(json.dumps({"ok": False, "error": "o faster-whisper não está instalado"}))
+            return 1
+        try:
+            ws = palavras(sys.argv[2], sys.argv[3] if len(sys.argv) > 3 else "pt")
+        except Exception as e:
+            print(json.dumps({"ok": False, "error": str(e)}))
+            return 1
+        print(json.dumps({"ok": True, "palavras": ws}, ensure_ascii=False))
+        return 0
     if acao != "baixar":
         print(json.dumps({"ok": False, "error": f"ação desconhecida: {acao}"}))
         return 2

package/app/ansi.js

@@ -1,55 +0,0 @@
-/* ansi.js — a saída do terminal virando HTML com as cores do PrimoCode.
- *
- * A mesma tradução do app.js (a janela do /rc), agora num arquivo que a IDE
- * também carrega. Só o que o PrimoCode realmente emite: cor 256 (38;5;N),
- * negrito e reset. O resto dos códigos (mover cursor, apagar linha) é desenho
- * de terminal e é descartado — na página quem rola é o navegador.
- *
- * O `estado` atravessa os pedaços: o Node corta a saída onde der, e um
- * "\x1b[38;5;45m" pode chegar num pedaço e o texto colorido no seguinte.
- */
-(function (raiz) {
-  "use strict";
-  var ANSI = /\x1b\[([0-9;?]*)([a-zA-Z])/g;
-
-  function fugir(s) {
-    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-  }
-
-  function paraHtml(texto, estado) {
-    var fora = "";
-    var ultimo = 0;
-    var m;
-    ANSI.lastIndex = 0;
-    function abrir() {
-      var classes = [];
-      if (estado.cor) classes.push("c" + estado.cor);
-      if (estado.forte) classes.push("forte");
-      return classes.length ? '<span class="' + classes.join(" ") + '">' : "";
-    }
-    function fechar() { return (estado.cor || estado.forte) ? "</span>" : ""; }
-
-    while ((m = ANSI.exec(texto)) !== null) {
-      var pedaco = texto.slice(ultimo, m.index);
-      if (pedaco) fora += abrir() + fugir(pedaco) + fechar();
-      ultimo = m.index + m[0].length;
-      if (m[2] !== "m") continue;
-      var partes = m[1].split(";");
-      for (var i = 0; i < partes.length; i++) {
-        var n = partes[i];
-        if (n === "" || n === "0") { estado.cor = null; estado.forte = false; }
-        else if (n === "1") estado.forte = true;
-        else if (n === "38" && partes[i + 1] === "5") { estado.cor = partes[i + 2]; i += 2; }
-        else if (n === "39") estado.cor = null;
-        else if (n === "22") estado.forte = false;
-      }
-    }
-    var resto = texto.slice(ultimo);
-    if (resto) fora += abrir() + fugir(resto) + fechar();
-    // \r sozinho é o terminal voltando ao começo da linha para redesenhar;
-    // na página ele só deixaria um caractere invisível no meio do texto.
-    return fora.replace(/\r(?!\n)/g, "");
-  }
-
-  raiz.PrimoAnsi = { paraHtml: paraHtml, fugir: fugir };
-})(window);