primocode 10.14.1 → 10.15.1

package/voz/primo_voz/hud.py

@@ -0,0 +1,275 @@
+"""hud.py — a tela do Primo (macOS, PyObjC + WKWebView).
+
+Uma janela GRANDE e normal (ocupa a área visível da tela, com os botões de
+fechar/minimizar/redimensionar no canto, título transparente) que carrega hud.html:
+calendário e compromissos de hoje, o robô 3D (é o próprio Primo; cai no SVG se o WebGL falhar),
+clima, música com disco girando, anéis da máquina, rede e o visualizador de voz.
+Abre no monitor onde está o mouse. Este arquivo só hospeda: os dados vêm de tela.py.
+
+    entra (stdin):  mensagens do painel.py  ({"estado":..,"nivel":..,"transcricao":..})
+    sai (stdout):   {"acao":"ptt"} quando a pessoa clica
+Esconder: ESC, "esconde o painel" ou ctrl+opt+P (este precisa de Acessibilidade).
+Teste sem voz:  python -m primo_voz.hud --demo
+"""
+from __future__ import annotations
+
+import json
+import math
+import os
+import queue
+import sys
+import threading
+import time
+from pathlib import Path
+
+from primo_voz import identidade, tela as td
+from primo_voz import painel as pn
+from primo_voz.sons import Sons
+
+AQUI = Path(__file__).resolve().parent
+
+
+def main(demo: bool = False, entrada=None, saida=None, ao_iniciar=None, ao_sair=None) -> int:
+    """entrada/saida/ao_iniciar/ao_sair: o modo app (app.py) liga o painel ao motor de voz sem passar por stdin/stdout."""
+    try:
+        from AppKit import (NSApplication, NSApplicationActivationPolicyRegular, NSImage, NSMenu, NSMenuItem, NSBackingStoreBuffered, NSColor,
+                            NSEvent, NSScreen, NSWindow)
+        from Foundation import NSMakeRect, NSObject, NSTimer, NSURL
+        import objc
+        from WebKit import WKWebView, WKWebViewConfiguration, WKUserContentController
+    except ImportError as e:
+        sys.stderr.write(f"o painel precisa do PyObjC ({e.name})\n")
+        return 3
+
+    p = pn.Painel()
+    fila: "queue.Queue[str]" = queue.Queue()
+    sons = Sons(os.environ.get("PRIMOCODE_SEM_SONS") != "1")
+
+    def emitir(obj: dict) -> None:
+        if saida:
+            saida(obj)
+        else:
+            sys.stdout.write(json.dumps(obj) + "\n")
+            sys.stdout.flush()
+
+    def js(msg: dict) -> None:
+        fila.put("window.primo(" + json.dumps(msg, ensure_ascii=False) + ")")
+
+    class Janela(NSWindow):
+        def canBecomeKeyWindow(self):
+            return True
+
+        def canBecomeMainWindow(self):
+            return True
+
+    class Alvo(NSObject):
+        def tick_(self, _):
+            n = 0
+            while n < 40:
+                try:
+                    cod = fila.get_nowait()
+                except queue.Empty:
+                    break
+                self.web.evaluateJavaScript_completionHandler_(cod, None)
+                n += 1
+            if self.jan.isMiniaturized():
+                return
+            if p.visivel != bool(self.jan.isVisible()):
+                if p.visivel:
+                    self.jan.deminiaturize_(None)
+                    self.jan.makeKeyAndOrderFront_(None)
+                    js({"boot": True})
+                    sons.tocar("boot")
+                else:
+                    self.jan.orderOut_(None)
+
+    class Dono(NSObject):
+        def windowShouldClose_(self, _):          # fechar o painel só esconde; o PrimoCode segue
+            p.visivel = False
+            return True
+
+        def applicationWillTerminate_(self, _n):
+            if ao_sair:
+                try:
+                    ao_sair()
+                except Exception:
+                    pass
+
+        def applicationShouldHandleReopen_hasVisibleWindows_(self, _a, _v):   # clique no Dock traz de volta
+            p.visivel = True
+            return True
+
+    class Msg(NSObject, protocols=[objc.protocolNamed("WKScriptMessageHandler")]):
+        def userContentController_didReceiveScriptMessage_(self, ucc, msg):
+            try:
+                m = json.loads(str(msg.body()))
+            except ValueError:
+                return
+            a = m.get("acao")
+            if a == "erro":                     # erro de JavaScript da página: vai para o terminal
+                sys.stderr.write("hud.html: " + str(m.get("arg")) + "\n")
+                sys.stderr.flush()
+            elif a == "sair":
+                p.visivel = False
+            elif a in ("ptt", "entrar"):
+                emitir({"acao": a})
+            elif a == "print":                  # esconde o HUD para o print pegar a tela de verdade
+                p.visivel = False
+                threading.Timer(0.6, lambda: pn.executar_acao(m)).start()
+                threading.Timer(2.2, lambda: setattr(p, "visivel", True)).start()
+            elif td.acao(m):
+                pass
+            else:
+                def _fazer():
+                    pn.executar_acao(m)
+                    if a == "midia":
+                        time.sleep(0.4)
+                        js({"musica": td.musica()})
+                threading.Thread(target=_fazer, daemon=True).start()
+
+    app = NSApplication.sharedApplication()
+    app.setActivationPolicy_(NSApplicationActivationPolicyRegular)   # app de verdade: Dock e Cmd+Tab
+    try:                                                              # nome e ícone do Primo, mesmo fora do bundle
+        from AppKit import NSBundle
+        info = NSBundle.mainBundle().infoDictionary()
+        info["CFBundleName"] = info["CFBundleDisplayName"] = "Primo"
+        icone = AQUI / "vendor" / "primo-icone.png"
+        if icone.exists():
+            app.setApplicationIconImage_(NSImage.alloc().initWithContentsOfFile_(str(icone)))
+    except Exception as e:
+        sys.stderr.write(f"hud: ícone: {e}\n")
+    barra = NSMenu.alloc().init()
+    raiz = NSMenuItem.alloc().init()
+    barra.addItem_(raiz)
+    menu = NSMenu.alloc().init()
+    for rot, sel, tec in (("Sobre o Primo", "orderFrontStandardAboutPanel:", ""), (None, None, None),
+                          ("Esconder o Primo", "hide:", "h"), (None, None, None), ("Sair do Primo", "terminate:", "q")):
+        menu.addItem_(NSMenuItem.separatorItem() if rot is None else
+                      NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(rot, sel, tec))
+    raiz.setSubmenu_(menu)
+    app.setMainMenu_(barra)
+    mouse = NSEvent.mouseLocation()
+    alvo_tela = next((s for s in NSScreen.screens() if s.frame().origin.x <= mouse.x < s.frame().origin.x + s.frame().size.width
+                      and s.frame().origin.y <= mouse.y < s.frame().origin.y + s.frame().size.height), NSScreen.mainScreen())
+    tela = alvo_tela.visibleFrame()          # maximizada, sem cobrir Dock nem barra de menu
+    # título | fechar | minimizar | redimensionar | conteúdo sob a barra de título
+    jan = Janela.alloc().initWithContentRect_styleMask_backing_defer_(tela, 1 | 2 | 4 | 8 | (1 << 15), NSBackingStoreBuffered, False)
+    jan.setTitlebarAppearsTransparent_(True)
+    jan.setTitleVisibility_(1)               # sem texto de título
+    jan.setTitle_("Primo")
+    jan.setReleasedWhenClosed_(False)
+    dono = Dono.alloc().init()
+    jan.setDelegate_(dono)
+    app.setDelegate_(dono)
+    jan.setMinSize_((900, 600))
+    jan.setOpaque_(True)
+    jan.setBackgroundColor_(NSColor.colorWithSRGBRed_green_blue_alpha_(0.043, 0.043, 0.039, 1.0))
+    jan.setHasShadow_(False)
+    cfg = WKWebViewConfiguration.alloc().init()
+    cfg.preferences().setValue_forKey_(True, "allowFileAccessFromFileURLs")      # o hud.html lê o .glb local (vendor/)
+    msg_h = Msg.alloc().init()
+    cfg.userContentController().addScriptMessageHandler_name_(msg_h, "primo")
+    web = WKWebView.alloc().initWithFrame_configuration_(NSMakeRect(0, 0, tela.size.width, tela.size.height), cfg)
+    web.setAutoresizingMask_(2 | 16)
+    web.setValue_forKey_(False, "drawsBackground")
+    jan.setContentView_(web)
+    url = NSURL.fileURLWithPath_(str(AQUI / "hud.html"))
+    web.loadFileURL_allowingReadAccessToURL_(url, NSURL.fileURLWithPath_(str(AQUI)))
+    jan.makeKeyAndOrderFront_(None)
+    app.activateIgnoringOtherApps_(True)
+    alvo = Alvo.alloc().init()
+    alvo.jan, alvo.web = jan, web
+    NSTimer.scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_(1 / 30, alvo, b"tick:", None, True)
+    threading.Timer(1.2, lambda: (js({"nome": identidade.ler()["nome"]}), js({"robo": identidade.ler()["robo"]}), js({"boot": True}), sons.tocar("boot"))).start()
+
+    def esconder():
+        p.visivel = False
+
+    def tecla(ev):
+        if ev.keyCode() == 53:                    # ESC
+            esconder()
+            return None
+        return ev
+    NSEvent.addLocalMonitorForEventsMatchingMask_handler_(1 << 10, tecla)
+
+    def atalho(ev):
+        f = ev.modifierFlags()
+        if (f & 0x40000) and (f & 0x80000) and ev.keyCode() == 35:
+            p.visivel = not p.visivel
+    try:
+        NSEvent.addGlobalMonitorForEventsMatchingMask_handler_(1 << 10, atalho)
+    except Exception:
+        pass
+
+    def medir():
+        am = pn.Amostrador()
+        cache: dict = {}
+        k = 0
+        while True:
+            try:
+                js({"maquina": td.maquina(am)})
+                js({"musica": td.musica()})
+                if k % 20 == 0:
+                    js({"clima": td.clima_widget(cache)})
+            except Exception as e:
+                sys.stderr.write(f"hud: {e}\n")
+            k += 1
+            time.sleep(1)
+    threading.Thread(target=medir, daemon=True).start()
+
+    def agenda():            # em outra thread: o pedido de permissão do Calendário pode demorar
+        evs: dict = {"permissao": "pendente", "eventos": []}
+        k = 0
+        while True:
+            try:
+                if k % 12 == 0 or evs["permissao"] != "ok":     # sem acesso, olha a cada 5 s (a pessoa pode ter liberado)
+                    evs = td.eventos_do_mes()
+                    js({"calendario": {"permissao": evs["permissao"], "dias": sorted({e["dia"] for e in evs["eventos"]})}})
+                if evs["permissao"] == "ok":
+                    js({"hoje": td.hoje_lista(evs["eventos"], time.time())})
+            except Exception as e:
+                sys.stderr.write(f"hud agenda: {e}\n")
+            k += 1
+            time.sleep(5)
+    threading.Thread(target=agenda, daemon=True).start()
+
+    def ler():
+        for l in (entrada if entrada is not None else sys.stdin):
+            try:
+                m = json.loads(l)
+            except ValueError:
+                continue
+            p.aplicar(m)
+            js(m)
+            if "estado" in m or "nivel" in m:
+                js({"barras": td.barras(p.estado, p.nivel)})
+        if entrada is None:
+            os._exit(0)
+
+    def encenar():
+        roteiro = [("dormindo", "", "", 3), ("ouvindo", "roda os testes do projeto", "", 4),
+                   ("pensando", "roda os testes do projeto", "", 3),
+                   ("falando", "roda os testes do projeto", "Rodei. Passou tudo, 412 testes. Um aviso no painel.", 5)]
+        while True:
+            for est, tr, rs, dur in roteiro:
+                p.aplicar({"estado": est})
+                js({"estado": est, "transcricao": tr, "parcial": est == "ouvindo", "resposta": rs})
+                fim = time.time() + dur
+                while time.time() < fim:
+                    v = abs(math.sin(time.time() * 9) * math.sin(time.time() * 2.3)) if est in ("ouvindo", "falando") else 0
+                    js({"barras": td.barras(est, v)})
+                    time.sleep(0.06)
+                if est == "falando":
+                    js({"evento": "sucesso"})
+    if entrada is not None:
+        threading.Thread(target=ler, daemon=True).start()
+    elif "--livre" not in sys.argv:
+        threading.Thread(target=encenar if demo else ler, daemon=True).start()
+    if ao_iniciar:
+        ao_iniciar(js, p)
+    app.run()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(demo="--demo" in sys.argv))

package/voz/primo_voz/identidade.py

@@ -0,0 +1,88 @@
+"""identidade.py — quem é o assistente e quem é a pessoa.
+
+O assistente se chama "Primo" até a pessoa dar outro nome ("seu nome agora é
+Luna", ou `primocode voz nome Luna`). A palavra de ativação é esse nome. Fica em
+~/.primocode/voz.json, junto com o nome da pessoa e as chaves de luz e som.
+
+Personalidade: curta, natural, humor leve. Cumprimenta pela hora, lembra o nome
+da pessoa, e varia a frase (nunca a mesma resposta robótica duas vezes seguidas).
+"""
+from __future__ import annotations
+
+import json
+import os
+import random
+import re
+from pathlib import Path
+from typing import Optional
+
+PADRAO = {"nome": "Primo", "pessoa": "", "luz": True, "sons": True, "robo": "spline", "voz": "francisca", "tts": "edge"}
+
+
+def arquivo() -> Path:
+    return Path(os.environ.get("PRIMOCODE_VOZ_CONFIG") or (Path.home() / ".primocode" / "voz.json"))
+
+
+def ler() -> dict:
+    try:
+        d = json.loads(arquivo().read_text("utf-8"))
+        cfg = {**PADRAO, **{k: d[k] for k in PADRAO if k in d}}
+        if cfg["robo"] not in ("spline", "expressive"):   # valor antigo ou torto: o padrão
+            cfg["robo"] = PADRAO["robo"]
+        return cfg
+    except Exception:
+        return dict(PADRAO)
+
+
+def salvar(**campos) -> dict:
+    cfg = {**ler(), **campos}
+    a = arquivo()
+    a.parent.mkdir(parents=True, exist_ok=True)
+    a.write_text(json.dumps(cfg, ensure_ascii=False, indent=2), "utf-8")
+    return cfg
+
+
+def _nome_valido(x: str) -> Optional[str]:
+    x = re.sub(r"[^\wÀ-ÿ \-]", "", x or "").strip()
+    palavras = x.split()
+    if not 1 <= len(palavras) <= 2 or len(x) > 20 or len(x) < 2:
+        return None
+    return " ".join(w[:1].upper() + w[1:] for w in palavras)
+
+
+def aprender(texto: str) -> Optional[dict]:
+    """"seu nome agora é Luna" / "pode me chamar de Joel" → o que gravar (ou None)."""
+    t = " ".join(str(texto or "").split()).strip(" .!?,")
+    m = re.search(r"(?:seu nome (?:agora )?é|vou te chamar de|(?:a partir de agora )?você se chama|te chamo de)\s+(.+)$", t, re.I)
+    if m and _nome_valido(m.group(1)):
+        return {"nome": _nome_valido(m.group(1))}
+    m = re.search(r"(?:pode me chamar de|meu nome é|me chama de|eu sou o|eu sou a)\s+(.+)$", t, re.I)
+    if m and _nome_valido(m.group(1)):
+        return {"pessoa": _nome_valido(m.group(1))}
+    return None
+
+
+def periodo(hora: int) -> str:
+    return "Bom dia" if 5 <= hora < 12 else "Boa tarde" if 12 <= hora < 18 else "Boa noite"
+
+
+def saudacao(hora: int, pessoa: str = "", nome: str = "Primo", rnd: Optional[random.Random] = None) -> str:
+    r = rnd or random
+    p = f", {pessoa}" if pessoa else ""
+    if hora < 5:
+        opcoes = [f"Ainda de pé{p}? Tô aqui.", f"Madrugada, hein{p}. Bora, mas sem exagero."]
+    else:
+        opcoes = [f"{periodo(hora)}{p}! {nome} na área.", f"{periodo(hora)}{p}. Pode falar.",
+                  f"{periodo(hora)}{p}, tô ouvindo."]
+    return r.choice(opcoes)
+
+
+FEITO = ["Feito.", "Pronto.", "Tá na mão.", "Resolvido."]
+ERRO = ["Opa, deu ruim. Olha o painel.", "Travei aqui. O detalhe tá no painel."]
+NAO_ENTENDI = ["Não peguei essa. Repete?", "Hã? Fala de novo."]
+
+
+def variar(opcoes, ultimo: str = "", rnd: Optional[random.Random] = None) -> str:
+    r = rnd or random
+    cand = [o for o in opcoes if o != ultimo] or list(opcoes)
+    return r.choice(cand)

package/voz/primo_voz/luz.py

@@ -0,0 +1,137 @@
+"""luz.py — a luz do teclado reage ao estado do Primo.
+
+MacBook: o teclado embutido só tem brilho (branco). O método: o framework
+privado CoreBrightness (KeyboardBrightnessClient) via PyObjC, carregado em
+tempo de execução; guarda o brilho e o modo automático da pessoa e restaura no
+fim. Teclado RGB externo: OpenRGB SDK (servidor local, porta 6742), se houver
+`openrgb` em PATH e o módulo `openrgb` instalado. Sem suporte, ou com
+PRIMOCODE_SEM_LUZ=1 / "luz": false em voz.json, tudo vira silêncio.
+
+    ouvindo = respira · pensando = pulso duplo · falando = segue a voz · erro = pisca
+"""
+from __future__ import annotations
+
+import math
+import os
+import sys
+import threading
+import time
+from typing import Optional
+
+
+def respira(t: float, periodo: float = 4.0, base: float = 0.10, topo: float = 0.45) -> float:
+    return base + (topo - base) * (0.5 - 0.5 * math.cos(t / periodo * math.tau))
+
+
+def pulso(t: float, periodo: float = 1.1, base: float = 0.08, topo: float = 0.8) -> float:
+    """dois toques curtos e uma pausa (tipo coração apressado: o Primo está pensando)."""
+    x = (t % periodo) / periodo
+    forca = max(math.exp(-((x - 0.1) ** 2) / 0.002), 0.7 * math.exp(-((x - 0.3) ** 2) / 0.002))
+    return base + (topo - base) * forca
+
+
+def alvo(estado: str, t: float, nivel: float = 0.0, erro_ate: float = 0.0, agora: float = 0.0) -> Optional[float]:
+    """Brilho 0..1 que o estado pede agora (None = não mexer)."""
+    if erro_ate > agora:
+        return 0.9 if int((erro_ate - agora) * 8) % 2 == 0 else 0.0
+    if estado == "ouvindo":
+        return respira(t)
+    if estado in ("pensando", "executando"):
+        return pulso(t)
+    if estado == "falando":
+        return 0.15 + 0.85 * min(1.0, nivel)
+    if estado == "interrompido":
+        return 0.7
+    return 0.0 if estado == "dormindo" else 0.12
+
+
+class _Mac:
+    def __init__(self) -> None:
+        import objc
+        from Foundation import NSBundle
+        NSBundle.bundleWithPath_("/System/Library/PrivateFrameworks/CoreBrightness.framework").load()
+        self._c = objc.lookUpClass("KeyboardBrightnessClient").alloc().init()
+        ids = self._c.copyKeyboardBacklightIDs() or []
+        if not ids:
+            raise RuntimeError("sem luz de teclado")
+        self._k = ids[0]
+        self.antes = float(self._c.brightnessForKeyboard_(self._k))
+        self.auto = bool(self._c.isAutoBrightnessEnabledForKeyboard_(self._k))
+        self._c.enableAutoBrightness_forKeyboard_(False, self._k)
+
+    def definir(self, v: float) -> None:
+        self._c.setBrightness_fadeSpeed_commit_forKeyboard_(min(1.0, max(0.0, v)), 60, False, self._k)
+
+    def restaurar(self) -> None:
+        self._c.setBrightness_fadeSpeed_commit_forKeyboard_(self.antes, 200, False, self._k)
+        self._c.enableAutoBrightness_forKeyboard_(self.auto, self._k)
+
+
+class _OpenRGB:
+    """Teclado RGB externo pelo servidor do OpenRGB. Cor ciano, intensidade = brilho."""
+
+    def __init__(self) -> None:
+        from openrgb import OpenRGBClient
+        from openrgb.utils import RGBColor
+        self._cor = RGBColor
+        self._cli = OpenRGBClient(name="Primo")
+        self._tec = [d for d in self._cli.devices if "keyboard" in str(d.type).lower()]
+        if not self._tec:
+            raise RuntimeError("sem teclado RGB")
+
+    def definir(self, v: float) -> None:
+        for d in self._tec:
+            d.set_color(self._cor(int(56 * v), int(225 * v), int(255 * v)))
+
+    def restaurar(self) -> None:
+        for d in self._tec:
+            d.set_mode("direct")
+
+
+class Luz:
+    def __init__(self, ligada: bool = True) -> None:
+        self.dev = None
+        self.estado = "esperando"
+        self.nivel = 0.0
+        self._erro_ate = 0.0
+        self._vivo = True
+        if not ligada or os.environ.get("PRIMOCODE_SEM_LUZ") == "1":
+            return
+        for fabrica in ((_Mac,) if sys.platform == "darwin" else ()) + (_OpenRGB,):
+            try:
+                self.dev = fabrica()
+                break
+            except Exception:
+                continue
+        if self.dev:
+            threading.Thread(target=self._animar, daemon=True).start()
+
+    def mudar(self, estado: str, nivel: Optional[float] = None) -> None:
+        self.estado = estado
+        if nivel is not None:
+            self.nivel = nivel
+
+    def erro(self) -> None:
+        self._erro_ate = time.time() + 0.9
+
+    def _animar(self) -> None:
+        t0 = time.time()
+        while self._vivo:
+            agora = time.time()
+            v = alvo(self.estado, agora - t0, self.nivel, self._erro_ate, agora)
+            if v is not None:
+                try:
+                    self.dev.definir(v)
+                except Exception:
+                    self.dev = None
+                    return
+            time.sleep(1 / 20)
+
+    def fechar(self) -> None:
+        self._vivo = False
+        if self.dev:
+            time.sleep(0.1)
+            try:
+                self.dev.restaurar()
+            except Exception:
+                pass